0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Menghindari null

Dasar-Dasar Option.

Menghindari null adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Masalah dengan null

Dalam banyak bahasa, nilai yang tidak ada direpresentasikan dengan null. Namun, null menyebabkan NullPointerException yang ditakuti saat Anda lupa memeriksanya.

Scala menyediakan alternatif yang lebih aman: tipe Option.

Apa Itu Option?

Option[A] merepresentasikan nilai yang mungkin ada atau tidak ada. Tipe ini memiliki tepat dua kasus:

  • Some(value) saat suatu nilai ada
  • None saat tidak ada nilai

Tipe itu sendiri memberi tahu Anda bahwa suatu nilai mungkin tidak ada.

object Main {
  def main(args: Array[String]): Unit = {
    val present: Option[Int] = Some(42)
    val absent: Option[Int] = None
    println(present)
    println(absent)
  }
}

Membuat Some

Bungkus nilai yang sudah ada dalam Some untuk menyatakan bahwa nilai tersebut pasti ada.

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

Merepresentasikan Ketiadaan dengan None

None adalah satu-satunya nilai yang digunakan saat tidak ada apa pun. Nilai ini berlaku untuk tipe Option apa pun.

object Main {
  def lookup(found: Boolean): Option[Int] =
    if (found) Some(100) else None
  def main(args: Array[String]): Unit = {
    println(lookup(true))
    println(lookup(false))
  }
}

Fungsi yang Mungkin Gagal

Mengembalikan Option membuat kemungkinan tidak adanya hasil menjadi eksplisit dalam tanda tangan tipe. Pemanggil tidak dapat mengabaikannya.

object Main {
  def findUser(id: Int): Option[String] =
    if (id == 1) Some("Grace") else None
  def main(args: Array[String]): Unit = {
    println(findUser(1))
    println(findUser(2))
  }
}

Memeriksa dengan isDefined dan isEmpty

isDefined memberi tahu Anda apakah sebuah Option merupakan Some, sedangkan isEmpty memberi tahu Anda apakah nilainya None.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(5)
    val b: Option[Int] = None
    println(a.isDefined)
    println(b.isEmpty)
  }
}

Mencocokkan Pola pada Option

Karena Option adalah ADT sealed, Anda dapat melakukan pencocokan pola terhadapnya. Cara ini menangani keberadaan dan ketiadaan dengan jelas.

object Main {
  def greet(name: Option[String]): String = name match {
    case Some(n) => s"Hello, $n"
    case None    => "Hello, stranger"
  }
  def main(args: Array[String]): Unit = {
    println(greet(Some("Bo")))
    println(greet(None))
  }
}

Option dari Nilai Nullable

Jika Anda harus bekerja dengan kode yang mengembalikan null, bungkus kode tersebut dengan Option(...). Ini mengubah null menjadi None dan nilai nyata apa pun menjadi Some.

object Main {
  def main(args: Array[String]): Unit = {
    val maybe = Option("data")
    val nothing = Option(null)
    println(maybe)
    println(nothing)
  }
}

Pustaka Standar Mengembalikan Option

Banyak metode bawaan sudah mengembalikan Option alih-alih berisiko menghasilkan error. Misalnya, List.headOption menangani daftar kosong dengan aman.

object Main {
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3)
    val empty = List.empty[Int]
    println(xs.headOption)
    println(empty.headOption)
  }
}

Mengapa Memilih Option daripada null?

Option lebih baik daripada null karena:

  • Membuat nilai yang tidak ada terlihat dalam tipe
  • Memaksa pemanggil menangani kasus ketiadaan
  • Menghilangkan NullPointerExceptions
  • Dapat dikomposisikan dengan map, flatMap, dan for-comprehension

Menggabungkan Semuanya

Pencarian kecil yang mengembalikan Option, lalu ditangani dengan aman melalui pencocokan pola.

object Main {
  val prices = Map("apple" -> 3, "pear" -> 5)
  def priceOf(item: String): Option[Int] = prices.get(item)
  def main(args: Array[String]): Unit = {
    priceOf("apple") match {
      case Some(p) => println(s"costs $p")
      case None    => println("not for sale")
    }
    println(priceOf("banana"))
  }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang Option.

Rangkuman

Anda telah mempelajari cara menghindari null dengan Option:

  • Option[A] adalah Some(value) atau None
  • Menjadikan kemungkinan ketiadaan eksplisit dalam tipe
  • Periksa dengan isDefined/isEmpty atau pencocokan pola
  • Gunakan Option(x) untuk membungkus nilai nullable
  • Metode pustaka seperti headOption dan Map.get mengembalikan Option

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghindari null” gratis?

Ya — teks lengkap “Menghindari null” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menghindari null”?

Dasar-Dasar Option. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Menghindari null” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Menghindari null
  2. map dan flatMap pada Option
  3. getOrElse dan fold
  4. Option dalam for-comprehension
← Kembali ke Scala for Backend Engineering & Functional Programming