Kotlin Academy · Lekcja

Wybór właściwej funkcji zakresu: przewodnik decyzyjny

Wybierz właściwą funkcję zakresu na podstawie odbiorcy, typu zwracanego i intencji.

Wybór właściwej funkcji zakresu: przewodnik decyzyjny to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Pięć funkcji, dwa wymiary

Funkcje zakresu Kotlin różnią się w dwóch wymiarach: styl odbiorcy (this lub it) oraz zwracana wartość (odbiorca lub wynik lambdy). Należy dokonać wyboru na podstawie intencji.

Macierz decyzyjna

apply: this / odbiorca. also: it / odbiorca. run: this / lambda. let: it / lambda. with: this / lambda (bez odbiorcy wywoływanego za pomocą kropki).

apply: konfiguracja i zwracanie

Należy użyć apply do konfiguracji obiektu w łańcuchu wywołań w stylu buildera.

class Config {
    var host: String = ""
    var port: Int = 0
}
fun main() {
    val cfg = Config().apply {
        host = "localhost"
        port = 8080
    }
    println("${cfg.host}:${cfg.port}")
}

also: efekty uboczne

Należy użyć also, aby rejestrować, walidować lub wywoływać efekt uboczny podczas przekazywania odbiorcy dalej.

fun main() {
    val items = listOf(1, 2, 3, 4)
        .also { println("got ${it.size} items") }
        .filter { it % 2 == 0 }
    println(items)
}

let: przekształcanie i bezpieczna obsługa wartości null

Należy użyć let do bezpiecznych przekształceń obsługujących wartości null lub do ograniczania zakresu zmiennej.

fun main() {
    val name: String? = "Ada"
    val length = name?.let { it.length } ?: 0
    println(length)
}

run: dostęp do wielu członków z wynikiem

Należy użyć run, gdy wynik jest obliczany na podstawie wielu członków odbiorcy — pozwala to uniknąć prefiksów it..

class User(val name: String, val age: Int)
fun main() {
    val description = User("Ada", 35).run {
        "Name: $name, Age: $age"
    }
    println(description)
}

with: grupowanie operacji na istniejącym obiekcie

Należy użyć with(obj) { ... }, gdy miejsce wywołania nie jest kontrolowane (brak łańcucha z kropką), ale potrzebne jest grupowanie operacji z użyciem this.

class Builder {
    val parts = mutableListOf<String>()
    fun add(s: String) { parts.add(s) }
    fun build(): String = parts.joinToString("-")
}
fun main() {
    val b = Builder()
    val result = with(b) {
        add("hello")
        add("kotlin")
        build()
    }
    println(result) // hello-kotlin
}

Wybór na podstawie intencji

Należy zadać sobie pytania: (1) Czy potrzebuję z powrotem odbiorcy, czy wyniku pochodnego? (2) Czy preferuję this, czy it? Odpowiedzi wskażą właściwą funkcję.

class Box { var w = 0; var h = 0; fun area() = w * h }
fun main() {
    // Configure and return Box -> apply
    val box = Box().apply { w = 3; h = 4 }
    // Compute area from box -> let or run
    val area = box.let { it.area() }
    // Side effect, keep box -> also
    val sameBox = box.also { println("area=${it.area()}") }
    println("$box / $area / $sameBox")
}

Porównanie: apply a also

Obie funkcje zwracają odbiorcę. apply używa this (dobrze nadaje się do ustawiania pól). also używa it (dobrze nadaje się do jawnego odwoływania się do odbiorcy, często w efektach ubocznych).

class Item { var name = "" }
fun main() {
    val a = Item().apply { name = "apply" } // implicit this
    val b = Item().also { it.name = "also" } // explicit it
    println("${a.name} / ${b.name}")
}

Porównanie: let a run

Obie funkcje zwracają wynik lambdy. let używa it (dobrze nadaje się do prostych przekształceń i bezpiecznej obsługi wartości null). run używa this (dobrze nadaje się do wywoływania wielu członków).

class Calculator(val a: Int, val b: Int) {
    fun sum() = a + b
    fun product() = a * b
}
fun main() {
    val calc = Calculator(3, 4)
    val s = calc.let { it.sum() }                  // simple
    val combo = calc.run { "sum=${sum()} product=${product()}" } // multi-member
    println("$s / $combo")
}

Praktyczny potok

Rzeczywisty łańcuch wywołań często wykorzystuje kilka funkcji zakresu jednocześnie.

class Request(var url: String = "", var headers: Map<String, String> = emptyMap())
fun main() {
    val response = Request()
        .apply {
            url = "https://api.example.com"
            headers = mapOf("Accept" to "json")
        }
        .also { println("request: ${it.url}") }
        .let { req -> "GET ${req.url}" }
    println(response)
}

Ściągawka

Szybki przewodnik po wyborze właściwego narzędzia.

// apply: this, returns receiver — configure object
// also: it, returns receiver — side effects in chain
// let: it, returns lambda result — transform / null-safety
// run: this, returns lambda result — multi-member compute
// with: this, returns lambda result — group operations on existing obj
fun main() { println("Scope functions: pick by receiver style + return value") }

Szybkie sprawdzenie

Która funkcja zakresu używa this jako odbiorcy i jednocześnie zwraca samego odbiorcę?

Podsumowanie

Funkcję zakresu należy wybrać na podstawie intencji: apply (konfiguracja i zwrócenie odbiorcy), also (efekt uboczny i zwrócenie odbiorcy), let (przekształcanie z użyciem it), run (przekształcanie z użyciem this), with (grupowanie operacji na istniejącym obiekcie). Odpowiedni wybór określają dwa wymiary — styl odbiorcy i zwracana wartość.

Często zadawane pytania

Czy lekcja „Wybór właściwej funkcji zakresu: przewodnik decyzyjny” jest bezpłatna?

Tak — pełny tekst „Wybór właściwej funkcji zakresu: przewodnik decyzyjny” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wybór właściwej funkcji zakresu: przewodnik decyzyjny”?

Wybierz właściwą funkcję zakresu na podstawie odbiorcy, typu zwracanego i intencji. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Wybór właściwej funkcji zakresu: przewodnik decyzyjny”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

apply i with: konfiguracja i zwracanie
let i run: przekształcanie i zakres
also: efekty uboczne bez zmiany odbiorcy
Wybór właściwej funkcji zakresu: przewodnik decyzyjny

← Powrót do Kotlin Academy