Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Ungkapan berbanding Pernyataan

Semuanya ialah ungkapan

Pelajaran 3 daripada 413 langkah

Ungkapan berbanding Pernyataan ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Expression berbanding Pernyataan

Pernyataan melakukan sesuatu tetapi tidak mengembalikan apa-apa yang berguna. Expression dinilai menjadi suatu nilai.

Dalam Scala, hampir semuanya ialah expression. Ini ialah idea teras yang membentuk cara Anda menulis kod.

if ialah Expression

Dalam banyak bahasa, if ialah pernyataan. Dalam Scala, if/else mengembalikan nilai, jadi Anda boleh menetapkannya terus kepada val.

Anda tidak memerlukan pemboleh ubah berasingan yang ditetapkan dalam setiap cabang.

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

Blok ialah Expression

Blok { ... } juga ialah expression. Nilainya ialah nilai baris terakhir.

Jadi, Anda boleh mengira nilai perantaraan, kemudian mengakhirinya dengan hasil.

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

match ialah Expression

Padanan corak dengan match juga mengembalikan nilai. Setiap cabang menghasilkan suatu hasil, dan keseluruhan expression menghasilkan nilai cabang yang sepadan.

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)
  }
}

Jenis Unit

Sesetengah expression wujud hanya untuk kesan sampingannya, seperti println. Expression tersebut mengembalikan Unit, yang ditulis sebagai ().

Unit serupa dengan void dalam bahasa lain, tetapi masih merupakan nilai sebenar.

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

Mengembalikan Nilai daripada Function

Oleh sebab badan function ialah expression, expression terakhir ialah nilai pulangannya. Anda jarang memerlukan kata kunci return.

Di sini, badan function ialah satu expression tunggal.

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))
  }
}

Function Berorientasikan Expression

Sesuatu function boleh menjadi expression blok yang baris terakhirnya ialah hasil. Ini memastikan logik kekal ringkas dan mengelakkan nilai sementara yang boleh diubah.

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))
  }
}

Tidak Perlu Perubahan

Oleh sebab if dan match ialah expression, Anda boleh menetapkan hasilnya kepada val dan bukannya mengubah var.

Ini menghasilkan kod yang lebih bersih dan lebih berfungsi.

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)
  }
}

Menggubah Expression

Oleh sebab segala-galanya mengembalikan nilai, expression boleh disarang dan digubah secara bebas. Output satu expression menjadi input kepada expression yang lain.

Kebolehgubahan ini ialah sebab utama Scala terasa begitu ekspresif.

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

Mengapa Ini Penting

Kod berorientasikan expression:

Mengurangkan keperluan terhadap pemboleh ubah yang boleh diubah
Menjadikan aliran nilai lebih jelas
Boleh digubah secara semula jadi menjadi program yang lebih besar
Serasi sepenuhnya dengan ketidakbolehubahan

Kesemuanya Bersama

Di sini, expression blok mengandungi expression if, yang semuanya ditetapkan kepada satu hasil tidak boleh ubah.

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)
  }
}

Semakan Pantas

Semak pemahaman Anda tentang expression.

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari bahawa dalam Scala, hampir semuanya ialah expression:

if/else, match dan blok semuanya mengembalikan nilai
Nilai blok ialah expression terakhirnya
Expression yang menghasilkan kesan sampingan mengembalikan Unit (())
Expression terakhir bagi function ialah nilai pulangannya
Ini mengurangkan perubahan dan meningkatkan kebolehgubahan

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Ungkapan berbanding Pernyataan” percuma?

Ya — teks penuh “Ungkapan berbanding Pernyataan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Ungkapan berbanding Pernyataan”?

Semuanya ialah ungkapan Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Ungkapan berbanding Pernyataan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian