Kotlin Academy · Lekcja

Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String

Buduj praktyczne rozszerzenia użytkowe w stylu Androida dla typowych wzorców.

Lekcja 4 z 414 kroki

Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String 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.

Rozszerzenia w rzeczywistych projektach

Rozszerzenia są szczególnie przydatne w przypadku typów frameworka, których nie można modyfikować: Context, View, String i kolekcji. Poniżej przedstawiono praktyczne wzorce pochodzące bezpośrednio z produkcyjnych baz kodu Androida.

Pomocnicza funkcja Context.toast

Rozbudowane wywołanie Toast.makeText(...).show() można opakować w jednowierszowe rozszerzenie.

import android.content.Context
import android.widget.Toast
fun Context.toast(message: String, long: Boolean = false) {
    val duration = if (long) Toast.LENGTH_LONG else Toast.LENGTH_SHORT
    Toast.makeText(this, message, duration).show()
}
// Usage: context.toast("Saved!")

Pomocnicze funkcje zasobów dla Context

Należy unikać rzutowania podczas wyszukiwania zasobów. Rozszerzenia poprawiają czytelność i bezpieczeństwo typów.

import android.content.Context
import androidx.core.content.ContextCompat
fun Context.color(res: Int) = ContextCompat.getColor(this, res)
fun Context.string(res: Int) = getString(res)
fun Context.dp(value: Int) = (value * resources.displayMetrics.density).toInt()
// Usage: val red = context.color(R.color.error)

View.show / View.hide

Widoczność View.VISIBLE / View.GONE można przełączać bez zbędnego kodu.

import android.view.View
fun View.show() { visibility = View.VISIBLE }
fun View.hide() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }
// Usage: progressBar.show(); button.hide()

View.setVisible(boolean)

Jednowierszowa funkcja przełączająca widoczność na podstawie warunku — zastępuje kod widoczności oparty na if-else.

import android.view.View
fun View.setVisible(visible: Boolean) {
    visibility = if (visible) View.VISIBLE else View.GONE
}
// Usage: errorLabel.setVisible(state.hasError)

Lambda View.onClick

Czytelniejszy odbiornik kliknięcia — przekazuje lambdę zamiast anonimowego OnClickListener.

import android.view.View
fun View.onClick(action: (View) -> Unit) {
    setOnClickListener(action)
}
// Usage:
// button.onClick { view -> println("clicked") }

String.isValidEmail

Rozszerzenia domenowe do walidacji typu String sprawiają, że logika biznesowa jest czytelniejsza.

fun String.isValidEmail(): Boolean {
    val regex = Regex("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")
    return regex.matches(this)
}
fun main() {
    println("ada@example.com".isValidEmail()) // true
    println("nope".isValidEmail())             // false
}

String.truncate

Długie ciągi znaków można skracać za pomocą wielokropka — to częsta pomocnicza funkcja interfejsu użytkownika.

fun String.truncate(max: Int, ellipsis: String = "..."): String =
    if (length <= max) this else substring(0, max - ellipsis.length) + ellipsis
fun main() {
    println("The quick brown fox".truncate(10)) // The qui...
    println("short".truncate(10))                // short
}

String.toTitleCase

Zamienia pierwszą literę każdego słowa na wielką — to częsta pomocnicza funkcja formatowania.

fun String.toTitleCase(): String = split(" ").joinToString(" ") {
    if (it.isEmpty()) it
    else it[0].uppercaseChar() + it.substring(1).lowercase()
}
fun main() {
    println("hello WORLD from kotlin".toTitleCase())
}

Rozszerzenie List: chunkedBy

Grupuje kolejne elementy według klucza — przydatne przy tworzeniu sekcji interfejsu użytkownika.

fun <T, K> List<T>.chunkedBy(keySelector: (T) -> K): List<List<T>> {
    val result = mutableListOf<MutableList<T>>()
    var lastKey: K? = null
    for (item in this) {
        val key = keySelector(item)
        if (key == lastKey) result.last().add(item)
        else { result.add(mutableListOf(item)); lastKey = key }
    }
    return result
}
fun main() {
    val data = listOf(1, 1, 2, 2, 2, 3, 1)
    println(data.chunkedBy { it }) // [[1, 1], [2, 2, 2], [3], [1]]
}

Pomocnicze funkcje Activity

Dzięki generykom reifikowanym można sprawić, aby nawigacja była bezpieczna pod względem typów i krótsza.

import android.content.Context
import android.content.Intent
inline fun <reified T> Context.startActivity() {
    startActivity(Intent(this, T::class.java))
}
// Usage: context.startActivity<MainActivity>()

Nie należy przesadzać

Rozszerzenia dodają elementy do globalnej przestrzeni nazw. Należy utrzymywać je wąsko ukierunkowane, ograniczać ich zakres (private/internal) i grupować według domeny — sprawdza się na przykład jeden plik na każdy typ receivera.

fun String.shout() = uppercase() + "!"
fun String.whisper() = lowercase() + "..."
fun main() {
    println("hello".shout())
    println("HELLO".whisper())
}

Szybkie sprawdzenie

Dlaczego rozszerzenia świetnie sprawdzają się w przypadku typów frameworka Androida, takich jak Context lub View?

Podsumowanie

Rozszerzenia doskonale nadają się do dodawania wygodnych funkcji pomocniczych do typów frameworka (Context, View, String, List). Typowe wzorce obejmują przełączanie widoczności, odbiorniki kliknięć, wyszukiwanie zasobów, walidację i formatowanie. Należy utrzymywać rozszerzenia wąsko ukierunkowane, ograniczać ich zakres i grupować według typu receivera.

Bezpłatny start

Ucz się Kotlin dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
51
Lekcje
203

Często zadawane pytania

Czy lekcja „Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String” jest bezpłatna?

Tak — pełny tekst „Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String” 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 „Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String”?

Buduj praktyczne rozszerzenia użytkowe w stylu Androida dla typowych wzorców. Ć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 „Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String”?

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. Funkcje rozszerzające: składnia i reguły wyszukiwania
  2. Właściwości rozszerzające i rozszerzenia obliczane
  3. Rozszerzenia o ograniczonym zakresie i rozszerzenia companion
  4. Praktyczne rozszerzenia: pomocnicze funkcje Context, View i String
← Powrót do Kotlin Academy