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

Statements के बजाय Expressions

हर चीज़ एक expression है

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

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

Expressions बनाम statements

Statement कोई काम करता है, लेकिन कोई उपयोगी परिणाम नहीं लौटाता। Expression का मूल्यांकन होकर एक value प्राप्त होती है।

Scala में लगभग सब कुछ expression है। यह एक मूल विचार है, जो आपके code लिखने के तरीके को आकार देता है।

if एक expression है

कई भाषाओं में if एक statement होता है। Scala में if/else एक value लौटाता है, इसलिए आप इसे सीधे किसी val में assign कर सकते हैं।

हर branch में अलग variable assign करने की आवश्यकता नहीं होती।

object Main {
  def main(args: Array[String]): Unit = {
    val temp = 30
    val label = if (temp > 25) "hot" else "mild"
    println(label)
  }
}

Blocks expressions होते हैं

एक block { ... } भी एक expression है। इसकी value इसकी अंतिम line की value होती है।

इसलिए आप बीच की values की गणना करके अंत में परिणाम दे सकते हैं।

object Main {
  def main(args: Array[String]): Unit = {
    val result = {
      val a = 2
      val b = 3
      a * b
    }
    println(result)
  }
}

match एक expression है

match के साथ pattern matching भी एक value लौटाती है। प्रत्येक branch एक परिणाम देती है और पूरा expression matched branch की value देता है।

object Main {
  def main(args: Array[String]): Unit = {
    val day = 3
    val name = day match {
      case 1 => "Mon"
      case 2 => "Tue"
      case 3 => "Wed"
      case _ => "Other"
    }
    println(name)
  }
}

Unit type

कुछ expressions केवल अपने side effect के लिए होते हैं, जैसे println। वे Unit लौटाते हैं, जिसे () लिखा जाता है।

Unit अन्य भाषाओं के void जैसा है, लेकिन फिर भी एक वास्तविक value है।

object Main {
  def main(args: Array[String]): Unit = {
    val nothing: Unit = println("side effect")
    println(nothing)
  }
}

Functions से लौटना

क्योंकि function का body एक expression होता है, इसलिए अंतिम expression उसकी return value होती है। आपको शायद ही कभी return keyword की आवश्यकता पड़ती है।

यहाँ function body एक single expression है।

object Main {
  def max(a: Int, b: Int): Int = if (a > b) a else b
  def main(args: Array[String]): Unit = {
    println(max(7, 4))
  }
}

Expression-केंद्रित functions

कोई function एक block expression हो सकता है, जिसकी अंतिम line परिणाम होती है। इससे logic संक्षिप्त रहता है और परिवर्तनीय अस्थायी values की आवश्यकता नहीं पड़ती।

object Main {
  def discount(price: Double): Double = {
    val rate = if (price > 100) 0.2 else 0.1
    price * (1 - rate)
  }
  def main(args: Array[String]): Unit = {
    println(discount(150.0))
  }
}

Mutation की आवश्यकता नहीं

क्योंकि if और match expressions हैं, इसलिए आप किसी var को बदलने के बजाय उनका परिणाम किसी val में assign कर सकते हैं।

इससे code अधिक साफ़ और functional बनता है।

object Main {
  def main(args: Array[String]): Unit = {
    val score = 85
    val grade = if (score >= 90) "A"
      else if (score >= 80) "B"
      else "C"
    println(grade)
  }
}

Expressions को संयोजित करना

क्योंकि हर चीज़ एक value लौटाती है, expressions को स्वतंत्र रूप से nest और compose किया जा सकता है। एक expression का output दूसरे का input बन जाता है।

यह composability Scala के expressive लगने का एक प्रमुख कारण है।

object Main {
  def main(args: Array[String]): Unit = {
    val n = 7
    val message = "n is " + (if (n % 2 == 0) "even" else "odd")
    println(message)
  }
}

यह महत्वपूर्ण क्यों है

Expression-केंद्रित code:

परिवर्तनीय variables की आवश्यकता कम करता है
values के flow को स्पष्ट बनाता है
बड़े programs में स्वाभाविक रूप से compose होता है
immutability के साथ पूरी तरह मेल खाता है

सब कुछ एक साथ

यहाँ एक block expression में एक if expression है, और दोनों को एक ही अपरिवर्तनीय परिणाम में assign किया गया है।

object Main {
  def main(args: Array[String]): Unit = {
    val total = {
      val items = 3
      val each = 12
      val raw = items * each
      if (raw > 30) raw - 5 else raw
    }
    println(total)
  }
}

त्वरित जाँच

Expressions पर अपनी समझ जाँचिए।

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

पुनरावलोकन

आपने सीखा कि Scala में लगभग सब कुछ एक expression है:

if/else, match और blocks सभी values लौटाते हैं
Block की value उसकी अंतिम expression होती है
Side effect वाली expressions Unit (()) लौटाती हैं
Function की अंतिम expression उसकी return value होती है
इससे mutation कम होती है और composability बेहतर होती है

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

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

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

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

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

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

क्या “Statements के बजाय Expressions” पाठ निःशुल्क है?

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

“Statements के बजाय Expressions” में मैं क्या सीखूँगा?

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

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

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

“Statements के बजाय Expressions” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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