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

Significant Indentation

वैकल्पिक braces

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

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

वैकल्पिक Braces

Scala 3 में significant indentation शुरू किया गया है, जिसे optional braces syntax भी कहा जाता है। Blocks को { } में लपेटने के बजाय आप उन्हें सीमांकित करने के लिए indentation का उपयोग कर सकते हैं।

Curly braces अब भी काम करते हैं और पूरी तरह मान्य हैं।
Indentation-आधारित कोड अधिक साफ़ और Python-जैसा होता है।

object Main:
  def main(args: Array[String]): Unit =
    println("No braces needed")

Indented Method Bodies

= के बाद आने वाला method body indented block हो सकता है। समान indentation स्तर वाला प्रत्येक statement उसी body का हिस्सा होता है।

अंतिम expression return value होता है।

object Main:
  def square(x: Int): Int =
    val result = x * x
    result

  def main(args: Array[String]): Unit =
    println(square(5))

Indented if Expressions

Control structures नई शांत syntax का उपयोग करते हैं। if cond then के बाद branch को indent करें, और else को if के साथ समान स्तर पर रखें।

Braces के बिना वाली शैली में then आवश्यक है।
Condition के चारों ओर parentheses आवश्यक नहीं हैं।

object Main:
  def main(args: Array[String]): Unit =
    val n = 7
    val label =
      if n % 2 == 0 then "even"
      else "odd"
    println(label)

Indented for Loops

for loop side effects के लिए do या collections बनाने के लिए yield का उपयोग करता है; दोनों के साथ indentation होती है।

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 3 do
      println(s"line $i")

    val doubled =
      for i <- 1 to 3 yield i * 2
    println(doubled)

Indented while Loops

while loop optional-braces शैली में do के बाद indented block का उपयोग करता है।

object Main:
  def main(args: Array[String]): Unit =
    var i = 0
    while i < 3 do
      println(s"i = $i")
      i += 1

Indented match Expressions

Pattern matching स्वाभाविक रूप से indentation के अनुकूल है। case clauses को match के नीचे indent किया जाता है।

object Main:
  def describe(n: Int): String =
    n match
      case 0 => "zero"
      case 1 => "one"
      case _ => "many"

  def main(args: Array[String]): Unit =
    println(describe(1))
    println(describe(9))

Class और Trait Bodies

Classes, traits और objects भी अपने braces हटा सकते हैं। Header के बाद का colon : indented body शुरू करता है।

class Point(x: Int, y: Int):
  def show: String = s"($x, $y)"

object Main:
  def main(args: Array[String]): Unit =
    println(Point(2, 3).show)

The end Marker

लंबे indented blocks के लिए आप definition कहाँ समाप्त होती है, यह स्पष्ट करने हेतु end marker जोड़ सकते हैं। इससे बड़े methods या classes की readability बेहतर होती है।

रूप: end <name> या end if, end while आदि।
यह वैकल्पिक है और compiler इसकी जाँच करता है।

object Main:
  def greet(name: String): String =
    val msg = s"Hello, $name"
    msg
  end greet

  def main(args: Array[String]): Unit =
    println(greet("Ada"))
  end main
end Main

Braces और Indentation को मिलाना

आप दोनों शैलियों को स्वतंत्र रूप से मिला सकते हैं। कुछ teams nested मामलों में स्पष्टता के लिए braces बनाए रखती हैं। Indentation के नियम केवल वहीं लागू होते हैं जहाँ braces अनुपस्थित हों।

object Main:
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3)
    val total =
      xs.foldLeft(0)((acc, x) => acc + x)
    println(total)
  }

सामान्य Indentation समस्याएँ

Indentation अर्थपूर्ण होती है, इसलिए सुसंगत रहें।

Tabs को spaces के साथ मिलाने के बजाय केवल spaces का उपयोग करें।
गलत alignment वाली line अनजाने में किसी block से बाहर जा सकती है।
Template bodies (classes/objects) के लिए colon : आवश्यक है, लेकिन = के बाद method bodies के लिए नहीं।

object Main:
  def main(args: Array[String]): Unit =
    val items = List("a", "b")
    items.foreach: item =>
      println(item.toUpperCase)

कम-Braces वाला Argument Syntax

Scala 3 colon के बाद block argument देने की भी अनुमति देता है। items.foreach: x => indented lambda body शुरू करता है और nested parentheses तथा braces से बचाता है।

object Main:
  def main(args: Array[String]): Unit =
    val nums = List(1, 2, 3, 4)
    val evens = nums.filter: n =>
      n % 2 == 0
    println(evens)

त्वरित जाँच

Significant indentation की अपनी समझ जाँचें।

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

पुनरावृत्ति

आपने Scala 3 की significant indentation सीखी।

Blocks { } के बजाय indentation का उपयोग कर सकते हैं।
Control structures then, do और yield का उपयोग करते हैं।
Class/object/trait bodies colon : से शुरू होती हैं।
end markers लंबे blocks को स्पष्ट करते हैं।
दोनों शैलियों को मिलाया जा सकता है; spacing में सुसंगत रहें।

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 2 do
      if i == 1 then println("first")
      else println("second")
  end main
end Main

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

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

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

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

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

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

क्या “Significant Indentation” पाठ निःशुल्क है?

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

“Significant Indentation” में मैं क्या सीखूँगा?

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

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

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

“Significant Indentation” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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