CodeGym /Kursy /Kotlin SELF /takeIf i takeUnless: warunki ochronne i powiazanie z Elvi...

takeIf i takeUnless: warunki ochronne i powiazanie z Elvis ?:

Kotlin SELF
Poziom 27, Lekcja 4
Dostępny

1. Wprowadzenie

Kiedy dopiero zaczynasz pisac kod, if wydaje sie uniwersalnym srubokretem: da sie nim i sprawdzic, i przypisac, i wypisac, i nawet „wychowac” uzytkownika komunikatem „wpisz to normalnie”. I to prawda. Ale z czasem (czasem juz po dwoch plikach kodu) pojawia sie nowy problem: czesto nie potrzebujesz „rozgaleziac sie”, tylko „odfiltrowac wartosc”.

Wyobraz sobie typowa sytuacje z naszej aplikacji konsolowej (kontynuujemy rozwijanie aplikacji CLI z komendami typu add, list, remove itd.). Uzytkownik wpisuje napis, a my chcemy:

  • wziac go, jesli jest sensowny (nie pusty, nie z samych spacji, nie -1, nie "abc" zamiast liczby),
  • w przeciwnym razie dostac null, zeby dalej ladnie to obsluzyc przez znane juz null-safety i Elvis ?:.

I wlasnie tutaj takeIf i takeUnless sa jak male „filtry” dla wartosci.

2. Czym jest takeIf: „zostaw wartosc, jesli przechodzi test”

takeIf to funkcja rozszerzajaca (extension function), ktora wywoluje sie na samej wartosci i ktora zwraca:

  • ta sama wartosc, jesli warunek jest prawdziwy,
  • null, jesli warunek jest falszywy.

Czyli logike da sie czytac mniej wiecej tak: „wez to, jesli…”.

Sygnature lepiej zapamietac nie jako straszna matematyke, tylko jako sens:

value.takeIf { conditionForValue }  // zwroci value albo null

Kluczowy efekt: wynik staje sie nullable (T?), a to znaczy, ze dalej mozemy zastosowac:

  • safe call ?.
  • Elvis ?:
  • zwykle sprawdzenie if (x != null)

W dokumentacji Kotlin i w przykladach czesto spotkasz styl .takeIf { it >= 0 } ?: ... jako zwarty sposob „wziecia wartosci tylko wtedy, gdy jest poprawna”.

Mini-tabela dla mozgu

Narzedzie Idea Zwraca
takeIf { cond }
„Zostaw wartosc, jesli cond = true”
T?
takeUnless { cond }
„Zostaw wartosc, jesli cond = false”
T?
?:
„Jesli po lewej jest null — wez prawa strone” wynik nie-null (zwykle)

3. Elvis ?: w tym polaczeniu: „jesli nie pasuje — podstaw fallback”

Z operatorem Elvis zapoznales/as sie w temacie o null-safety: wyrazenie w postaci

val x = nullableValue ?: defaultValue

oznacza: jesli po lewej jest null, bierzemy defaultValue.

Dlaczego takeIf prawie zawsze „kuma sie” z ?:? Bo takeIf celowo robi z tego null jako „marker niepoprawnosci”, a ?: zamienia ten marker na zrozumiale zachowanie: wartosc domyslna, komunikat o bledzie, wczesne wyjscie z funkcji albo cos jeszcze.

4. Przyklad: walidujemy wynik indexOf

Teraz sytuacja z prawdziwego zycia napisow: indexOf(...) zwraca -1, jesli nie znalazl. To nie wyjatek i nie blad JVM — po prostu „tak sie umowilismy”. Ale -1 nie da sie uzyc jako indeksu do substring.

Zwykle pisze sie tak:

val at = email.indexOf('@')
if (at >= 0) { ... } else { ... }

A mozna tak — przez takeIf + Elvis:

fun main() {
    val email = "aliceexample.com"
    val at = email.indexOf('@')

    val safeAt = at.takeIf { it >= 0 } ?: -1
    println(safeAt) // -1
}

OK, na razie to nie jest super przydatne: po prostu zwrocilismy -1. Bardziej przydatne jest uzycie fallbacku, ktory jest gwarantowanie bezpieczny.

Na przyklad czasem wygodnie jest powiedziec: „jesli nie ma "@" — uznajemy, ze nie ma domeny”:

fun main() {
    val email = "aliceexample.com"
    val at = email.indexOf('@')

    val domain = at.takeIf { it >= 0 }
        ?.let { email.substring(it + 1) } // (o let pozniej, dzis bez niego)
        ?: "INVALID"

    println(domain) // INVALID
}

Ale stop. Nie przerabialismy jeszcze scope functions w tym dniu (to bedzie pozniej), wiec zrobmy to samo bez let, uczciwie i czytelnie:

fun main() {
    val email = "aliceexample.com"
    val at = email.indexOf('@')

    val domain = if (at.takeIf { it >= 0 } != null) {
        email.substring(at + 1)
    } else {
        "INVALID"
    }

    println(domain) // INVALID
}

Tutaj widac wazna mysl: takeIf to nie „zamiennik if na zawsze”, tylko narzedzie, ktore pozwala zamienic „zla wartosc” na null.

W oficjalnych przykladach Kotlin spotyka sie podobny trik: szuka sie indeksu, a potem robi .takeIf { it >= 0 } ?: s.length, zeby dostac bezpieczna granice.

5. Przyklad: „pusty napis po trim” to tez niepoprawne wejscie

Uzytkownik wpisal " " (trzy spacje). Formalnie to napis nie jest pusty (length = 3), ale znaczeniowo jest jak obietnice „zaczne sie uczyc od poniedzialku” — czyli zero.

Czesty wzorzec: najpierw trim(), potem sprawdzenie.

takeIf pozwala zapisac to bardzo liniowo:

fun main() {
    val raw = "   "
    val name = raw.trim().takeIf { it.isNotEmpty() } ?: "UNKNOWN"

    println(name) // UNKNOWN
}

Tutaj czyta sie prawie jak zdanie po polsku: „wez przyciety napis, jesli nie jest pusty, w przeciwnym razie UNKNOWN”.

6. takeUnless: „to samo, tylko odwrotnie”

takeUnless to lustrzany brat takeIf.

  • takeIf { cond } zostawia wartosc, gdy cond == true
  • takeUnless { cond } zostawia wartosc, gdy cond == false

Po co to jest, skoro mozna napisac takeIf { !cond }? Bo czasem inwersja wyglada prosciej wlasnie jako „jesli NIE…”.

Wyobrazmy sobie, ze w komendach naszego CLI zabraniany niektorych „slów zarezerwowanych” dla kategorii, np. "all" (bo komenda list all moze znaczyc „pokaz wszystko”).

fun main() {
    val rawCategory = "all"

    val category = rawCategory.trim()
        .takeUnless { it.lowercase() == "all" }
        ?: "uncategorized"

    println(category) // uncategorized
}

Brzmi OK: „wez kategorie, jesli to NIE all, w przeciwnym razie uncategorized”.

7. Jak to pomaga w CLI: schludne parsowanie argumentow

Teraz wazny praktyczny moment. W komendach typu:

  • add food 120 coffee
  • remove 3
  • list food

wejscie uzytkownika zawsze jest „brudne”: dodatkowe spacje, puste argumenty, dziwne liczby, czasem w ogole pusty wiersz.

Juz umiemy normalizowac spacje przez Regex("""\s+""").replace(...) (to bylo w poprzednim wykladzie). Teraz dodamy warunki ochronne przez takeIf/takeUnless, zeby kazda wartosc posrednia albo stawala sie poprawna, albo zamieniala sie w null.

Normalizujemy token: „napis albo null”

Zrobimy mala funkcje-pomocnik. Przyda sie praktycznie wszedzie: nazwa kategorii, tekst notatki, komenda.

fun normalizeToken(raw: String): String? {
    val cleaned = raw.trim()
    return cleaned.takeIf { it.isNotEmpty() }
}

I sprawdzmy:

fun main() {
    println(normalizeToken("  milk  ")) // milk
    println(normalizeToken("   "))      // null
}

Wynik null nie jest tu „zly” — to przydatny sygnal: dalej mozna zrobic ?: i zdecydowac, co robic.

Parsujemy dodatnia kwote: „liczba albo null”

W trackerze wydatkow kwota musi byc liczba i najczesciej — dodatnia. Z takeIf wygodnie da sie to zrobic bez zbednych galezi:

fun parsePositiveIntOrNull(raw: String): Int? {
    val n = raw.trim().toIntOrNull()
    return n?.takeIf { it > 0 }
}

Sprawdzmy:

fun main() {
    println(parsePositiveIntOrNull(" 120 ")) // 120
    println(parsePositiveIntOrNull("-5"))    // null
    println(parsePositiveIntOrNull("abc"))   // null
}

Tutaj dzialaja jednoczesnie dwie idee: toIntOrNull() daje null dla nienumerycznego wejscia, a takeIf { it > 0 } zamienia „liczbe, ale niewlasciwa” tez w null. W efekcie mamy jeden sygnal „nie przeszlo walidacji”.

takeIf + Elvis jako guard w jednej linii

Czasem chcesz w jednym wyrazeniu dostac albo poprawna wartosc, albo fallback.

Na przyklad: uzytkownik wpisuje remove id. Jesli id jest niepoprawne — uzywamy 0 jako markera (albo moglibysmy wypisac blad, ale dzis skupimy sie na wyrazeniu).

fun main() {
    val rawId = " -10 "
    val id = rawId.trim().toIntOrNull()?.takeIf { it >= 1 } ?: 0

    println(id) // 0
}

To bardzo przypomina klasyczna idiome z dokumentacji: „wez wartosc, jesli jest poprawna, w przeciwnym razie podstaw dlugosc/granice/domyslna”.

8. Mini-przyklad: parsowanie remove przez wyrazenia ochronne

Zrobimy maly fragment logiki dla komendy remove. Nie piszemy calego projektu w wykladzie, ale bedziemy trzymac jeden styl.

Scenariusz: uzytkownik wpisuje wiersz. Chcemy dostac id: Int?, gdzie null znaczy „nie wyszlo”.

fun parseRemoveIdOrNull(line: String): Int? {
    val parts = Regex("""\s+""").replace(line.trim(), " ").split(" ")

    if (parts.isEmpty()) return null
    if (parts[0].lowercase() != "remove") return null

    val rawId = parts.getOrNull(1) ?: return null
    return rawId.toIntOrNull()?.takeIf { it >= 1 }
}

Tak, tutaj jest if. To normalne. Uzywamy takeIf nie jako religii, tylko jako wygodnego „mini-filtra” na konkretnym kroku.

Mozna sprawdzic:

fun main() {
    println(parseRemoveIdOrNull("remove 3"))     // 3
    println(parseRemoveIdOrNull("remove -2"))    // null
    println(parseRemoveIdOrNull("remove abc"))   // null
}

Warto zauwazyc: takeIf pomaga dokladnie tam, gdzie „wartosc juz jest, ale trzeba sprawdzic warunek”.

9. Jak myslec o takeIf/takeUnless i gdzie sa na miejscu

Schemat myslenia: „zamien zle na null → obsluz jednym sposobem”

Kiedy opanujesz ten styl, kod czesto zaczyna wygladac jak tasma walidacji. Nawet bez scope functions (dzis ich nie ruszamy) mozna miec w glowie prosty schemat blokowy:

flowchart TD
    A[Surowa wartosc] --> B[Normalizacja: trim/replace]
    B --> C{Sprawdzenie warunku}
    C -->|OK| D[Wartosc]
    C -->|FAIL| E[null]
    E --> F[Elvis ?: fallback/komunikat/wyjscie]

Sens: takeIf/takeUnless to wygodna implementacja wezla „sprawdzenie warunku → null przy porazce”.

Kiedy takeIf/takeUnless poprawiaja czytelnosc, a kiedy przeszkadzaja

Wazne, zeby nie wpasc w typowa pulapke poczatkujacego: „o, nowa funkcja, to teraz naciagne ja na caly projekt”. Tak zwykle powstaja PR-y, po ktorych koledzy zaczynaja pic herbate rumiankowa zamiast kawy.

takeIf/takeUnless zwykle sa na miejscu, gdy warunek jest krotki i bezposrednio opisuje poprawnosc. Klasyczne przyklady: it >= 0, it.isNotEmpty(), it in 1..10. W przykladach Kotlin mozna spotkac styl, w ktorym napis zamienia sie w wartosc i od razu filtruje po dlugosci przez takeIf — to wlasnie dobry, prosty predykat.

Gdy warunek jest dlugi, z wieloma sprawdzeniami („i jeszcze to, i jeszcze tamto”), zwykle if jest czytelniejsze, bo mozesz rozlozyc mysl na kilka linii i nadac zmiennym sensowne nazwy.

Zestaw mini-przykladow (5–10 linii)

Czasem lepiej raz zobaczyc kilka krotkich sytuacji, niz sto razy uslyszec definicje.

Bierzemy napis tylko wtedy, gdy „wyglada jak komenda”

fun main() {
    val raw = "   add food 120 coffee   "
    val commandLine = raw.trim().takeIf { it.contains(' ') } ?: ""

    println(commandLine) // add food 120 coffee
}

Odrzucamy zbyt krotki token

fun main() {
    val token = "ok"
    val good = token.takeIf { it.length >= 3 } ?: "too_short"

    println(good) // too_short
}

takeUnless jako „zakaz wartosci”

fun main() {
    val category = "root"
    val safe = category.takeUnless { it == "root" } ?: "guest"

    println(safe) // guest
}

10. Typowe bledy przy uzywaniu takeIf/takeUnless

Blad nr 1: zapomniec, ze wynik jest nullable, i traktowac go jak zwykla wartosc.
takeIf i takeUnless prawie zawsze zwracaja T?, nawet jesli pierwotna wartosc byla T. Poczatkujacy pisze val x = s.takeIf { ... } i od razu robi x.length. Kompilator slusznie protestuje, a student — nie. Poprawka jest prosta: albo dodajesz Elvis ?:, albo sprawdzasz null, albo kontynuujesz lancuch przez safe call ?..

Blad nr 2: probowac zastapic takeIf cala „galezia logiki biznesowej”.
Jesli przy niepoprawnym wejsciu trzeba wypisac komunikat, poprosic o ponowienie, zalogowac blad albo wykonac rozne dzialania — to juz nie jest „filtrowanie wartosci”, tylko rozgalezienie zachowania. W takich miejscach if/when zwykle jest uczciwsze i bardziej czytelne: nie chowasz waznej logiki w jednej linii „dla urody”.

Blad nr 3: naduzywac takeUnless, gdy czytelnikowi latwiej zobaczyc takeIf.
takeUnless { it == "all" } moze wygladac OK, ale takeUnless { it.length < 3 } zmusza mozg do podwojnej negacji. Jesli naturalniej brzmi fraza „wez, jesli …”, uzyj takeIf. Jesli naturalniej „wez, jesli NIE …” — uzyj takeUnless.

Blad nr 4: pisac zbyt skomplikowane warunki bezposrednio w takeIf { ... }.
Gdy predykat rozrasta sie do „trzy warunki, dwa &&, jedno || i jeszcze nawiasy”, kod przestaje byc latwy do nauki. Wtedy lepiej wyniesc sprawdzenie do osobnej funkcji z mowiaca nazwa (np. isValidCategoryName(s)) albo chociaz zrobic posrednie val, a dopiero potem zastosowac takeIf.

Blad nr 5: mylic „marker niepoprawnosci” z „rzeczywistym znaczeniem null”.
W tym temacie null to wygodny techniczny sygnal „nie przeszlo walidacji”. Ale dalej w kursie bedziesz projektowac typy tak, aby null nie znaczyl „wszystkiego naraz”. Dlatego staraj sie, by null w Twoim kodzie byl albo jawnie oczekiwanym wynikiem (parse...OrNull), albo swiadoma „flaga” z takeIf/takeUnless, ktora od razu jest obsluzona przez ?: lub sprawdzenie.

1
Zadanie
Kotlin SELF, poziom 27, lekcja 4
Niedostępne
Powitanie gościa
Powitanie gościa
1
Zadanie
Kotlin SELF, poziom 27, lekcja 4
Niedostępne
Weryfikacja oceny
Weryfikacja oceny
1
Zadanie
Kotlin SELF, poziom 27, lekcja 4
Niedostępne
Domena z adresu
Domena z adresu
1
Zadanie
Kotlin SELF, poziom 27, lekcja 4
Niedostępne
Kategoria bez zakazu
Kategoria bez zakazu
1
Ankieta/quiz
Napisy — bardziej szczegółowo, poziom 27, lekcja 4
Niedostępny
Napisy — bardziej szczegółowo
Napisy — bardziej szczegółowo
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION