Scala for Backend Engineering & Functional Programming · Ders

Örtük Parametreler

Bağlam geçirme

Örtük Parametreler, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 1. 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.

Bağlamı otomatik olarak aktarma

Örtük parametreler, derleyicinin sizin için bir bağımsız değişken sağlamasına olanak tanır; bu bağımsız değişken kapsamda implicit ile işaretlenmiş değerlerden alınır. Yapılandırma veya biçimlendirme kuralları gibi “ortamdan gelen” bağlamları aktarmak için çok uygundurlar.

object Main {
  def greet(name: String)(implicit greeting: String): String =
    s"$greeting, $name!"
  implicit val defaultGreeting: String = "Hello"
  def main(args: Array[String]): Unit = {
    println(greet("Ann"))
  }
}

Örtük parametre listesi

Son parametre listesini implicit anahtar sözcüğüyle işaretleyin. Çağrı noktasında bu listeyi yazmadığınızda derleyici eşleşen örtük bir değer arar.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
  }
}

Örtük değerleri açıkça sağlama

Bir örtük parametreyi her zaman açıkça aktararak kapsamda bulunan değeri geçersiz kılabilirsiniz. Bu, tek seferlik durumlarda kullanışlıdır.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
    println(multiply(5)(2))
  }
}

Türe göre örtük çözümleme

Derleyici örtük değerleri ada göre değil, türe göre eşleştirir. Kapsamda tam olarak bir eşleşen örtük değer bulunmalıdır; aksi hâlde derleme belirsiz veya eksik eşleşme nedeniyle başarısız olur.

object Main {
  case class Config(env: String)
  def run()(implicit cfg: Config): String = s"running in ${cfg.env}"
  implicit val cfg: Config = Config("prod")
  def main(args: Array[String]): Unit = {
    println(run())
  }
}

Bir değeri çağırmak için implicitly

implicitly[T] yardımcısı, bir parametre adlandırmadan kapsamdan T türündeki örtük değeri doğrudan alır.

object Main {
  implicit val name: String = "Scala"
  def main(args: Array[String]): Unit = {
    val n = implicitly[String]
    println(n)
  }
}

Bağlam sınırı kısaltması

Bağlam sınırı olan [T: Ordering], Ordering[T] türündeki bir örtük parametre için kullanılan kısa yazımdır. Tür sınıflarıyla yaygın olarak kullanılır.

object Main {
  def max[T: Ordering](a: T, b: T): T = {
    val ord = implicitly[Ordering[T]]
    if (ord.gt(a, b)) a else b
  }
  def main(args: Array[String]): Unit = {
    println(max(3, 7))
    println(max("apple", "pear"))
  }
}

Bağlamı çağrılar boyunca aktarma

Örtük parametreler, birçok işlevin aynı bağlama ihtiyaç duyduğu durumlarda özellikle kullanışlıdır. Bağlamı bir kez örtük olarak işaretlediğinizde, iç içe çağrılar boyunca otomatik olarak aktarılır.

object Main {
  case class User(name: String)
  def log(msg: String)(implicit u: User): Unit =
    println(s"[${u.name}] $msg")
  def doWork()(implicit u: User): Unit = {
    log("started")
    log("finished")
  }
  implicit val current: User = User("admin")
  def main(args: Array[String]): Unit = {
    doWork()
  }
}

Örtük değerlerin arandığı yerler

Derleyici örtük değerleri yerel kapsamda, içe aktarımlarda ve ilgili türlerin eşlikçi nesnelerinde arar. Eşlikçi nesneleri varsayılan değerler sağlamak için düzenli bir yerdir.

object Main {
  case class Currency(symbol: String)
  object Currency {
    implicit val default: Currency = Currency("$")
  }
  def price(amount: Int)(implicit c: Currency): String = s"${c.symbol}$amount"
  def main(args: Array[String]): Unit = {
    println(price(50))
  }
}

Belirsizlik hataları

Aynı türde iki örtük değer kapsamdaysa derleyici belirsiz örtük değer hatası bildirir. Tür başına en fazla bir değer bulundurun veya değeri açıkça aktarın.

object Main {
  def label(x: Int)(implicit unit: String): String = s"$x$unit"
  implicit val unit: String = "px"
  def main(args: Array[String]): Unit = {
    // Only one implicit String in scope -> no ambiguity
    println(label(12))
  }
}

Varsayılana benzer davranış

Örtük parametreler, bağlamı dikkate alan bir varsayılan davranış biçimi sağlar: Aynı işlev çağrısı, hangi örtük değerin kapsamda olduğuna bağlı olarak farklı sonuçlar üretir.

object Main {
  def format(n: Double)(implicit decimals: Int): String =
    f"$n%.${decimals}f"
  implicit val d: Int = 2
  def main(args: Array[String]): Unit = {
    println(format(3.14159))
    println(format(3.14159)(4))
  }
}

Örtük değerleri ölçülü kullanın

Örtük parametreler güçlüdür; ancak aşırı kullanıldıklarında kodu takip etmeyi zorlaştırabilir. Bunları yürütme bağlamları, yapılandırmalar ve tür sınıfı örnekleri gibi gerçekten ortak kullanılan bağlamlarla sınırlayın.

object Main {
  case class Locale(code: String)
  def hello()(implicit loc: Locale): String =
    if (loc.code == "tr") "Merhaba" else "Hello"
  implicit val loc: Locale = Locale("tr")
  def main(args: Array[String]): Unit = {
    println(hello())
  }
}

Hızlı kontrol

Derleyici, örtük bir parametre için hangi değeri sağlayacağına nasıl karar verir?

Özet

Örtük parametreleri (Scala 2 biçimi) öğrendiniz:

Bir parametre listesinin otomatik olarak doldurulması için onu implicit ile işaretleyin
Çözümleme türe göre yapılır ve kapsamda benzersiz olmalıdır
implicitly[T] bir değeri çağırır; bağlam sınırları olan [T: TC] kısa yazımdır
Arama yerel kapsamı, içe aktarımları ve eşlikçi nesneleri kapsar
Bunları her şey için değil, ortak kullanılan bağlamlar için kullanın

Sıkça Sorulan Sorular

“Örtük Parametreler” dersi ücretsiz mi?

Evet — “Örtük Parametreler” 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.

“Örtük Parametreler” dersinde ne öğreneceğim?

Bağlam geçirme 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 1. dersidir.

“Örtük Parametreler” 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

← Scala for Backend Engineering & Functional Programming Sayfasına Dön