Scala for Backend Engineering & Functional Programming · Ders

Kapanımlar

Durumu yakalama

Kapanımlar, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 4. 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.

Kapanış nedir?

Kapanış, tanımlandığı çevreleyen kapsamdan değişkenleri yakalayan bir işlevdir. Bu değişkenlerin üzerine “kapanır” ve o kapsam sona erdikten sonra bile onlara erişimi korur.

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

Serbest bir değişkeni yakalama

x => x * factor ifadesinde x bir parametredir; ancak factor, kapsayan kapsamdan alınan bir serbest değişkendir. İşlev, bu değişkene bir başvuru taşır.

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

Kapanışlar kapsamlarını aşar

Bir işlev bir kapanış döndürdüğünde, tanımlayan işlev tamamlanmış olsa bile yakalanan değişkenler kapanış var olduğu sürece yaşamaya devam eder.

object Main {
  def makeAdder(n: Int): Int => Int = x => x + n
  def main(args: Array[String]): Unit = {
    val add10 = makeAdder(10)
    val add100 = makeAdder(100)
    println(add10(5))
    println(add100(5))
  }
}

Her kapanışın kendi yakalaması vardır

Bir işlev fabrikasını iki kez çağırmak, her biri kendi yakaladığı değeri hatırlayan iki bağımsız kapanış üretir.

object Main {
  def prefixer(p: String): String => String = s => p + s
  def main(args: Array[String]): Unit = {
    val withDr = prefixer("Dr. ")
    val withMr = prefixer("Mr. ")
    println(withDr("Smith"))
    println(withMr("Jones"))
  }
}

Değiştirilebilir durumu yakalama

Bir kapanış bir var değişkenini yakalayabilir ve bu değişkeni hem okuyup hem güncelleyebilir. Böylece kapanış, bir sayaç gibi çağrılar arasında durumu koruyabilir.

object Main {
  def main(args: Array[String]): Unit = {
    var count = 0
    val increment = () => { count += 1; count }
    println(increment())
    println(increment())
    println(increment())
  }
}

Sayaç fabrikası

Fikirleri birleştirin: Kendi özel var değişkenini yakalayan bir kapanış döndüren işlev, kapsüllenmiş ve bağımsız bir sayaç sağlar.

object Main {
  def counter(): () => Int = {
    var n = 0
    () => { n += 1; n }
  }
  def main(args: Array[String]): Unit = {
    val c1 = counter()
    val c2 = counter()
    println(c1())
    println(c1())
    println(c2())
  }
}

Kapanışlar kopyaları değil, başvuruları yakalar

Bir kapanış bir anlık görüntüyü değil, değişkenin kendisini yakalar. Yakalanan var kapanış oluşturulduktan sonra değişirse kapanış yeni değeri görür.

object Main {
  def main(args: Array[String]): Unit = {
    var msg = "first"
    val show = () => println(msg)
    show()
    msg = "second"
    show()
  }
}

val yakalamayı tercih edin

Değişmez bir val yakalamak sürprizleri önler: Yakalanan değer hiçbir zaman değişmez, dolayısıyla kapanış öngörülebilir şekilde davranır. İşlevsel kodda val yakalamayı tercih edin.

object Main {
  def main(args: Array[String]): Unit = {
    val taxRate = 0.2
    val withTax = (price: Double) => price * (1 + taxRate)
    println(withTax(100))
  }
}

Koleksiyon işlevleriyle kapanışlar

map, filter ve benzerlerine aktarılan lambda ifadeleri, dışarıdaki değişkenlere başvurduklarında kapanıştır. Bu, günlük Scala kullanımında son derece yaygındır.

object Main {
  def main(args: Array[String]): Unit = {
    val threshold = 3
    val nums = List(1, 2, 3, 4, 5)
    val big = nums.filter(_ > threshold)
    println(big)
  }
}

Döngülerde bir yakalama tuzağı

Scala'da bir for döngüsünün değişkeni, her yinelemede yeni bir bağlama oluşturur; bu nedenle kapanışlar birbirinden farklı değerleri yakalar. Bu, bazı diğer dillerde görülen klasik bir hatayı önler.

object Main {
  def main(args: Array[String]): Unit = {
    val fns = for (i <- 1 to 3) yield () => i
    println(fns.map(f => f()))
  }
}

Kapanışlar davranışı ve veriyi kapsüller

Bir kapanış, davranışı (işlev gövdesini) veriyle (yakalanan değişkenlerle) bir araya getirir. Bu, tek bir yönteme sahip küçük bir nesneye hafif bir alternatiftir.

object Main {
  def discounter(rate: Double): Double => Double = price => price * (1 - rate)
  def main(args: Array[String]): Unit = {
    val sale = discounter(0.25)
    println(sale(80))
    println(sale(200))
  }
}

Hızlı kontrol

Bir kapanış çevreleyen kapsamından neyi yakalar?

Özet

Kapanışları öğrendiniz:

Bir kapanış, kapsayan kapsamındaki serbest değişkenleri yakalar
Yakalanan değişkenler, tanımlayan işlevden daha uzun süre var olur
Her kapanış örneğinin kendine ait yakalanmış durumu vardır
Kapanışlar başvuruları yakalar; bu nedenle değiştirilebilir yakalamalar değişebilir
map/filter için kullanılan lambda ifadeleri günlük kapanış örnekleridir

Sıkça Sorulan Sorular

“Kapanımlar” dersi ücretsiz mi?

Evet — “Kapanımlar” 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.

“Kapanımlar” dersinde ne öğreneceğim?

Durumu yakalama 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 4. dersidir.

“Kapanımlar” 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