Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Pembina Pintar

Pembinaan yang disahkan

Pelajaran 2 daripada 413 langkah

Pembina Pintar ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 2 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.

Pembinaan yang Disahkan

Pembina pintar ialah kilang yang mengesahkan input sebelum menghasilkan nilai. Ia menjamin bahawa setiap tika yang anda pegang memenuhi invarian jenis tersebut.

Pembina mentah disembunyikan.
Hanya pembinaan yang disahkan tersedia kepada umum.

class Age private (val value: Int)
object Age:
  def of(v: Int): Option[Age] =
    if v >= 0 then Some(new Age(v)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(Age.of(30).map(_.value))

Pembina Peribadi

Menandakan pembina utama sebagai private menghalang pemanggil daripada memintas pengesahan. Objek pasangan menjadi satu-satunya pintu masuk.

class Percentage private (val value: Int)
object Percentage:
  def of(v: Int): Option[Percentage] =
    if v >= 0 && v <= 100 then Some(new Percentage(v)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(Percentage.of(50).map(_.value))
    println(Percentage.of(150))

Mengembalikan Option

Mengembalikan Option menandakan bahawa pembinaan mungkin gagal. Pemanggil mesti mengendalikan None, supaya data tidak sah tidak mengalir secara senyap.

class NonEmpty private (val value: String)
object NonEmpty:
  def of(s: String): Option[NonEmpty] =
    if s.nonEmpty then Some(new NonEmpty(s)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(NonEmpty.of("").map(_.value))
    println(NonEmpty.of("hi").map(_.value))

Mengembalikan Either untuk Perincian Ralat

Apabila anda mahu menerangkan sebab pengesahan gagal, kembalikan Either[Error, T]. Left membawa mesej yang deskriptif.

class Username private (val value: String)
object Username:
  def of(s: String): Either[String, Username] =
    if s.isEmpty then Left("empty")
    else if s.length > 10 then Left("too long")
    else Right(new Username(s))

object Main:
  def main(args: Array[String]): Unit =
    println(Username.of(""))
    println(Username.of("ada").map(_.value))

Pembina Pintar dengan case class

case class dengan pembina peribadi masih boleh digunakan. Perhatikan bahawa apply dan copy yang dijananya juga mesti dikawal, jadi takrifkan kilang tersuai dan kekalkan pembina sebagai peribadi.

case class Email private (value: String)
object Email:
  def of(s: String): Option[Email] =
    if s.contains("@") then Some(Email(s)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(Email.of("a@b.com"))
    println(Email.of("bad"))

Merantaikan Nilai yang Disahkan

Oleh sebab pembina pintar mengembalikan Option atau Either, anda boleh mengarangnya dengan pemahaman for untuk membina objek yang lebih besar dan disahkan.

case class Name private (value: String)
object Name:
  def of(s: String): Option[Name] =
    if s.nonEmpty then Some(Name(s)) else None

case class Person(name: Name, age: Int)

object Main:
  def make(n: String): Option[Person] =
    for nm <- Name.of(n) yield Person(nm, 20)

  def main(args: Array[String]): Unit =
    println(Main.make("Bob"))

Menormalkan Input

Pembina pintar juga boleh menormalkan data, contohnya dengan membuang ruang kosong atau menukarkan huruf kepada huruf kecil, supaya semua tika berkongsi bentuk kanonik.

case class Tag private (value: String)
object Tag:
  def of(s: String): Option[Tag] =
    val clean = s.trim.toLowerCase
    if clean.nonEmpty then Some(Tag(clean)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(Tag.of("  Scala  "))

Invarian Kekal Selama-lamanya

Setelah nilai melepasi pembina pintar, invarian itu dijamin sepanjang hayatnya. Kod hiliran boleh mempercayai nilai tersebut tanpa menyemak semula.

case class PositiveInt private (value: Int)
object PositiveInt:
  def of(n: Int): Option[PositiveInt] =
    if n > 0 then Some(PositiveInt(n)) else None

object Main:
  def doubleIt(p: PositiveInt): Int = p.value * 2 // always positive

  def main(args: Array[String]): Unit =
    PositiveInt.of(5).foreach(p => println(Main.doubleIt(p)))

Menggabungkan dengan Jenis Legap

Untuk nilai yang disahkan tanpa kos, gabungkan pembina pintar dengan jenis legap. Tiada objek pembalut diperuntukkan, namun pengesahan masih mengawal pembinaan.

object Domain:
  opaque type Score = Int
  def of(n: Int): Option[Score] =
    if n >= 0 && n <= 100 then Some(n) else None
  extension (s: Score) def value: Int = s

object Main:
  def main(args: Array[String]): Unit =
    println(Domain.of(88).map(_.value))

Pelbagai Peraturan Pengesahan

Laksanakan beberapa semakan mengikut turutan. Peraturan pertama yang gagal menghentikan proses dan mengembalikan ralat yang jelas.

object Password:
  def of(s: String): Either[String, String] =
    if s.length < 8 then Left("too short")
    else if !s.exists(_.isDigit) then Left("need a digit")
    else Right(s)

object Main:
  def main(args: Array[String]): Unit =
    println(Password.of("abc"))
    println(Password.of("abcdef12"))

Bila Hendak Menggunakan Pembina Pintar

Gunakannya apabila sesuatu jenis mempunyai invarian yang boleh dilanggar oleh pembinaan mentah.

Nombor berjulat, rentetan tidak kosong, id berformat.
Kembalikan Option untuk jawapan ya/tidak yang mudah, dan Either untuk sebab.
Kekalkan pembina mentah sebagai peribadi.

case class Port private (value: Int)
object Port:
  def of(n: Int): Option[Port] =
    if n >= 1 && n <= 65535 then Some(Port(n)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(Port.of(8080))
    println(Port.of(70000))

Semakan Ringkas

Uji pemahaman anda tentang pembina pintar.

Jawab dalam pelajaran interaktif

Rumusan

Anda telah mempelajari pembina pintar.

Sahkan input dalam kilang pasangan.
Jadikan pembina mentah peribadi.
Kembalikan Option atau Either untuk memaksa pengendalian kegagalan.
Normalkan input secara pilihan kepada bentuk kanonik.
Invarian kemudiannya kekal untuk sepanjang hayat nilai.

case class Even private (value: Int)
object Even:
  def of(n: Int): Option[Even] =
    if n % 2 == 0 then Some(Even(n)) else None

object Main:
  def main(args: Array[String]): Unit =
    println(Even.of(4))
    println(Even.of(5))

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 “Pembina Pintar” percuma?

Ya — teks penuh “Pembina Pintar” 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 “Pembina Pintar”?

Pembinaan yang disahkan 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 2 daripada 4.

Berapa lamakah pelajaran “Pembina Pintar” 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