0Pricing
Scala for Backend Engineering & Functional Programming · Ders

Türleri ve Değerleri Eşleştirme

Tür örüntüleri

Türleri ve Değerleri Eşleştirme, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

Tür Desenleri

match, sabit değerleri eşleştirmenin yanı sıra bir değerin türüne göre de dallanabilir. Buna tür deseni denir.

case x: Type => yazarsınız; değer bu türde olduğunda dal çalışır ve değer x'e bağlanır.

Türe Göre Eşleştirme

Bir değer Any gibi genel bir türe sahip olduğunda, tür deseniyle somut türünü öğrenebilirsiniz.

Her case x: T, çalışma zamanındaki türü denetler.

object Main {
  def describe(x: Any): String = x match {
    case i: Int    => "an Int"
    case s: String => "a String"
    case _         => "something else"
  }
  def main(args: Array[String]): Unit = {
    println(describe(5))
    println(describe("hi"))
    println(describe(3.14))
  }
}

Bağlanan Değeri Kullanma

Bağlanan ad, eşleşen türe sahip olur; bu nedenle o dalda ilgili yöntemleri güvenle çağırabilirsiniz.

Tür dönüştürme gerekmez: Derleyici, durumun içinde türü bilir.

object Main {
  def shout(x: Any): String = x match {
    case s: String => s.toUpperCase
    case i: Int    => (i * 2).toString
    case _         => "?"
  }
  def main(args: Array[String]): Unit = {
    println(shout("hello"))
    println(shout(21))
  }
}

Türü ve Değeri Birlikte Kullanma

Aynı match içinde değer desenlerini ve tür desenlerini karıştırabilirsiniz. Değer desenleri genellikle daha özeldir; bu nedenle onları önce yerleştirin.

object Main {
  def check(x: Any): String = x match {
    case 0       => "zero int"
    case i: Int  => s"nonzero int $i"
    case _       => "not an int"
  }
  def main(args: Array[String]): Unit = {
    println(check(0))
    println(check(7))
    println(check("x"))
  }
}

Double ve Boolean ile Eşleştirme

Tür desenleri, Double, Boolean ve Char dahil her türle çalışır.

object Main {
  def kind(x: Any): String = x match {
    case d: Double  => s"double $d"
    case b: Boolean => s"bool $b"
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(kind(2.5))
    println(kind(true))
  }
}

Koleksiyonları Türe Göre Eşleştirme

List gibi kapsayıcı türleri de eşleştirebilirsiniz. Burada bir listeyi diğer değerlerden ayırt ediyoruz.

object Main {
  def info(x: Any): String = x match {
    case l: List[_] => s"a list of size ${l.size}"
    case _          => "not a list"
  }
  def main(args: Array[String]): Unit = {
    println(info(List(1, 2, 3)))
    println(info("nope"))
  }
}

Yaygın Bir Kullanım: Any'yi İşleme

Tür desenleri, bir işlev Any aldığında ve günlük kaydı tutma veya serileştirme gibi işlemlerde türe göre farklı tepki vermesi gerektiğinde çok işe yarar.

object Main {
  def render(x: Any): String = x match {
    case i: Int    => s"int=$i"
    case d: Double => s"dbl=$d"
    case s: String => s"str=$s"
    case _         => "unknown"
  }
  def main(args: Array[String]): Unit = {
    List(1, 2.0, "three").foreach(v => println(render(v)))
  }
}

Sıra Hâlâ Önemlidir

Tüm eşleştirmelerde olduğu gibi tür desenleri de yukarıdan aşağıya denetlenir. Önce yerleştirilen daha genel bir tür, aşağıdaki daha özel türü gizleyebilir.

Her zaman en özel türden en genel türe doğru sıralayın.

object Main {
  def label(x: Any): String = x match {
    case s: String => "string first"
    case _: Any    => "anything"
  }
  def main(args: Array[String]): Unit = {
    println(label("hi"))
    println(label(99))
  }
}

Tür Silinmesi Uyarısı

Çalışma zamanında genel tür parametreleri silinir. Bu nedenle List[Int] ve List[String] aynı görünür. List[Int] ile eşleştirme yalnızca bunun bir List olduğunu denetler.

Açık olmak ve uyarılardan kaçınmak için List[_] kullanın.

Tür Desenleri Neden Kullanılır?

Tür desenleri şunları yapmanızı sağlar:

  • Genel bir türü dönüştürme yapmadan güvenle daraltmak
  • Farklı türlerdeki değerleri temiz bir şekilde işlemek
  • Değer desenleri ve koruyucularla birleştirmek

Bunlar, durum sınıfları ve ADT'lerle eşleştirmeye geçiş sağlar.

Hepsini Bir Araya Getirme

Karışık girdileri sınıflandırmak için değer ve tür desenlerini birleştirin.

object Main {
  def classify(x: Any): String = x match {
    case 0          => "zero"
    case i: Int     => "int"
    case s: String  => "text of length " + s.length
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(classify(0))
    println(classify(5))
    println(classify("hey"))
  }
}

Kısa Kontrol

Tür desenleri hakkındaki bilginizi test edin.

Özet

Türlerle eşleştirme yapmayı öğrendiniz:

  • case x: Type, çalışma zamanındaki türe göre eşleşir ve x'i bağlar
  • Bağlanan değer eşleşen türe sahip olduğundan tür dönüştürme gerekmez
  • Değer ve tür desenlerini karıştırın; en özeli önce yerleştirin
  • Genel parametreler silinir; bu nedenle List[_] kullanın

Sıkça Sorulan Sorular

“Türleri ve Değerleri Eşleştirme” dersi ücretsiz mi?

Evet — “Türleri ve Değerleri Eşleştirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

“Türleri ve Değerleri Eşleştirme” dersinde ne öğreneceğim?

Tür örüntüleri Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Türleri ve Değerleri Eşleştirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. match İfadeleri
  2. Türleri ve Değerleri Eşleştirme
  3. Koruyucular ve Bağlama
  4. Yapıdan Ayırma
← Scala for Backend Engineering & Functional Programming Sayfasına Dön