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 |
|---|---|---|
|
„Zostaw wartosc, jesli cond = true” | |
|
„Zostaw wartosc, jesli cond = false” | |
|
„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.
GO TO FULL VERSION