0Pricing
Kotlin Academy · Lekcja

also: efekty uboczne bez zmiany odbiorcy

Używaj also do rejestrowania, debugowania i operacji wykonywanych wyłącznie dla efektów ubocznych.

also: efekty uboczne bez zmiany odbiorcy to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 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.

also w skrócie

also uruchamia blok, w którym odbiorcą jest it, i zwraca odbiorcę bez zmian. Doskonale nadaje się do efektów ubocznych — rejestrowania, debugowania i walidacji — bez przerywania łańcucha wywołań.

Podstawy also

also { ... } wykonuje efekt uboczny i zwraca tę samą wartość, dzięki czemu wywołania mogą płynnie się łączyć.

fun main() {
    val nums = listOf(1, 2, 3, 4)
        .also { println("input: $it") }
        .filter { it % 2 == 0 }
        .also { println("filtered: $it") }
    println(nums)
}

also do rejestrowania

Należy dodawać instrukcje rejestrowania w środku potoku bez przerywania jego przepływu.

fun main() {
    val processed = "  Hello, Kotlin!  "
        .also { println("raw: '$it'") }
        .trim()
        .also { println("trimmed: '$it'") }
        .uppercase()
    println(processed)
}

also do debugowania

Należy użyć also, aby sprawdzić stan pośredni podczas refaktoryzacji — później można je usunąć bez zmiany łańcucha wywołań.

fun main() {
    val sum = (1..5).toList()
        .also { println("list: $it") }
        .sum()
        .also { println("sum: $it") }
    println("final: $sum")
}

also a apply

apply używa this (lepiej sprawdza się przy przypisaniach). also używa it (lepiej sprawdza się przy jawnych odwołaniach i efektach ubocznych).

class Counter {
    var value: Int = 0
}
fun main() {
    val c = Counter().apply { value = 10 } // uses this implicitly
    val d = Counter().also { it.value = 10 } // uses it explicitly
    println("${c.value} / ${d.value}")
}

also do efektów ubocznych podczas inicjalizacji

Przydaje się, gdy podczas tworzenia obiektu trzeba wykonać operację, która nie polega na ustawieniu właściwości.

class Repository {
    val cache = mutableMapOf<String, String>()
    fun init() = println("Repository initialized")
}
fun main() {
    val r = Repository().also { it.init() }
    r.cache["key"] = "value"
    println(r.cache)
}

also zwraca oryginał

Odbiorca jest przekazywany dalej bez zmian — łatwo można kontynuować łańcuch wywołań.

fun main() {
    val len = "Hello".also { println("got: $it") }.length
    println(len) // 5
}

also do walidacji

Należy uruchamiać asercje w środku łańcucha wywołań.

fun main() {
    val n = listOf(1, 2, 3, 4)
        .filter { it > 0 }
        .also { require(it.isNotEmpty()) { "must have positives" } }
        .sum()
    println(n)
}

Łączenie also i let

Należy użyć also do efektów ubocznych, a let do przekształcania wartości w tym samym potoku.

fun main() {
    val raw: String? = "  42  "
    val n = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim().toIntOrNull() }
        ?.also { println("parsed: $it") }
    println(n)
}

also do dodawania do kolekcji

Należy dodawać utworzony obiekt do listy bezpośrednio w łańcuchu wywołań.

class User(val name: String)
fun main() {
    val users = mutableListOf<User>()
    val ada = User("Ada").also { users.add(it) }
    val ben = User("Ben").also { users.add(it) }
    println(users.map { it.name })
}

Kiedy używać also

Należy sięgnąć po also, gdy potrzebny jest efekt uboczny (rejestrowanie, walidacja lub rejestracja), ale oryginalna wartość ma być przekazywana dalej.

fun main() {
    val total = listOf(10, 20, 30, 40, 50)
        .also { println("count: ${it.size}") }
        .filter { it >= 30 }
        .also { println("kept: $it") }
        .sum()
    println("total: $total")
}

Antywzorzec: also do ponownego przypisania

Nie należy używać also, gdy rzeczywiście trzeba przekształcić wartość — do tego służą let i run.

fun main() {
    val name = "ada"
    // BAD: also returns receiver, so upper is wrong
    // val upper = name.also { it.uppercase() } // upper == "ada"
    val upper = name.let { it.uppercase() }
    println(upper) // ADA
}

Szybkie sprawdzenie

Jaką wartość zwraca also po wykonaniu swojego bloku?

Podsumowanie

also uruchamia blok efektu ubocznego z it i zwraca odbiorcę. Należy go używać do rejestrowania, debugowania, walidacji i rejestracji — wszędzie tam, gdzie potrzebny jest wgląd bez zmieniania wartości. Do przekształceń należy zamiast tego użyć let lub run.

Często zadawane pytania

Czy lekcja „also: efekty uboczne bez zmiany odbiorcy” jest bezpłatna?

Tak — pełny tekst „also: efekty uboczne bez zmiany odbiorcy” 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 „also: efekty uboczne bez zmiany odbiorcy”?

Używaj also do rejestrowania, debugowania i operacji wykonywanych wyłącznie dla efektów ubocznych. Ć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 3 z 4.

Ile czasu zajmuje lekcja „also: efekty uboczne bez zmiany odbiorcy”?

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

  1. apply i with: konfiguracja i zwracanie
  2. let i run: przekształcanie i zakres
  3. also: efekty uboczne bez zmiany odbiorcy
  4. Wybór właściwej funkcji zakresu: przewodnik decyzyjny
← Powrót do Kotlin Academy