Scope functions — какво са, видове и приложение в Kotlin

Какво са scope functions?

Scope functions (функции на обхват) — набор от пет функции (let, run, with, apply, also), вградени в стандартната библиотека на Kotlin. Всяка от тях приема ламбда и временно променя обхвата на видимост така, че вътре в ламбдата кодът се изпълнява в контекста на конкретен обект. Това избягва повторението на името на обекта при множество извиквания и групира свързаните операции в един блок.

Две ключови характеристики различават scope functions: начинът на достъп до контекстния обект (чрез this или it) и връщаната стойност (самият контекстен обект или резултат от ламбда). Достъпът чрез this прави обекта имплицитен получател — методите и свойствата се извикват без префикс. Достъпът чрез it предава обекта като изричен параметър на ламбдата. Връщането на обект позволява изграждане на вериги, връщането на резултат — присвояване на трансформираната стойност.

Исторически, scope functions се появяват като заместител на класическия модел Builder и временни променливи за инициализация. Вместо създаване на отделен builder клас, програмистът пише apply { свойство1 = ...; свойство2 = ... }. Това намалява количеството код и прави инициализацията по-четима. В екосистемата на Kotlin, scope functions се използват във всички рамки и библиотеки като стандартен идиом на езика.

Сравнение на scope functions: this vs it, обект vs резултат

Изборът на подходяща scope function се определя от два въпроса: искате ли да използвате this или it за достъп до обекта, и искате ли да върнете самия обект или резултата от ламбда. Комбинацията от две бинарни характеристики дава четири възможни варианта, а with заема специално място като единствената функция, която не е разширение.

За конфигурация на обект без връщане на нова стойност използвайте apply (достъп чрез this) или also (достъп чрез it). За изчисляване на нова стойност на базата на обект използвайте let (достъп чрез it) или run (достъп чрез this). За групиране на извиквания без верига използвайте with. Следването на тази схема прави кода предвидим за други разработчици, запознати с Kotlin.

apply и also: конфигурация с връщане на обект

apply — scope function, която връща контекстния обект и предоставя достъп до него чрез this. Това е идеалният инструмент за инициализация на свойствата на обект след създаване. Вътре в apply блока могат да се задават свойства без повторение на името на обекта. Методът връща самия обект, което позволява вграждане на apply във вериги или използване в инициализатори.

data class ServerConfig(
    var host: String = "localhost",
    var port: Int = 8080,
    var useTls: Boolean = false
)

val config = ServerConfig().apply {
    host = "api.example.com"
    port = 443
    useTls = true
}

В листинга apply конфигурира ServerConfig, като осъществява достъп до свойствата директно чрез this (this е пропуснат). Без apply трябваше да се пише config.host = ..., config.port = ... — три повтарящи се препратки към една и съща променлива. Връщането на обект позволява запазване на резултата от конфигурацията в val config. also, за разлика от apply, предава обекта чрез it и е подходящ за странични ефекти.

fun saveUser(user: User) {
    validate(user).also { result ->
        println("Резултат от валидация: $result")
    }
    val savedUser = user.also {
        log("Saving user ${it.id}")
        database.save(it)
    }
}

В примера also се използва за логване — връщайки оригиналния обект, той изпълнява страничен ефект (отпечатване на съобщение) без да променя обекта. Това е верига: validate(user) връща User, also логва резултата и предава потребителя нататък. also е полезен и за добавяне на елементи в колекции или отстраняване на грешки в средата на верига от трансформации.

let и run: трансформации и изчисления

let — scope function, която връща резултата от ламбда и предава контекста чрез it. Това е основната функция за null-безопасни трансформации: ако обектът е nullable, комбинацията ?.let { } ще изпълни блока само при ненулева стойност. let се използва и за ограничаване на обхвата на видимост на временни променливи и map-подобни трансформации от един тип в друг.

fun findUser(id: Int): User?

val displayName = findUser(42)?.let { user ->
    "${user.name} (${user.email})"
} ?: "Unknown user"

// let с трансформация на колекция
val numbers = listOf("1", "2", "3")
val parsed = numbers.firstOrNull()?.let {
    it.toIntOrNull()
} ?: 0

В първия пример let се извиква чрез ?. — блокът се изпълнява само ако findUser е върнал ненулева стойност. Ламбдата приема user чрез it (може да се преименува за яснота) и връща форматиран низ. Ако потребителят не е намерен — Elvis операторът ?: дава стойност по подразбиране. Във втория пример let преобразува низ в число с потенциален null.

run — аналог на let с достъп чрез this, който връща резултата от ламбда. run е удобен за изчисления, където се изисква контекстът на обекта, но се връща нова стойност. Извикването run() без обект (като run { ... }) създава временен обхват на видимост за променливи. with — не-разширение с достъп чрез this, подходящо за групиране на извиквания без верига.

// run като контекстно-ориентирано изчисление
val transformed = listOf(1, 2, 3).run {
    filter { it > 1 }.map { it * 10 }
}
println(transformed) // [20, 30]

// with за групиране на извиквания
val info = with(StringBuilder()) {
    append("Name: ")
    append("Alice")
    toString()
}

В примера run върху списък връща резултата от филтриране и картографиране — самата трансформация, а не списъка. with приема StringBuilder като аргумент (не чрез точка) и вътре работи с this: append, append, toString. Резултатът от with — низът info. Изборът между run и with често е субективен, но with е за предпочитане, когато обектът се предава от друго място без верига от извиквания.

with: контекст без разширение

with се различава от останалите scope functions по това, че не е функция-разширение. Тя приема обекта като първи аргумент, а ламбдата като втори. Вътре в ламбдата обектът е достъпен чрез this. with е удобен за групиране на извиквания на методи на обекта без запазване на резултата или когато е необходимо временно „да се влезе“ в контекста за четене на няколко свойства.

val user = User("Alice", "alice@example.com", "Admin")

val summary = with(user) {
    "User $name has role $role and email $email"
}
println(summary)

// with за инициализация на UI компонент
with(TextView(context)) {
    text = "Hello"
    textSize = 18.0f
    setTextColor(Color.BLUE)
}

В първия пример with формира низа summary, като осъществява достъп до свойствата на user директно чрез this. Без with трябваше да се пише „User ${user.name} has role ${user.role}” — многократно повторение на user. Във втория пример with групира конфигурацията на TextView: всички методи и свойства се извикват на един обект без повторение. Недостатък на with — невъзможност за използване във верига, тъй като не е разширение и не връща контекстния обект.