0Pricing
Kotlin Academy · Aula

Extensões práticas: auxiliares de Context, View e String

Crie extensões utilitárias no estilo Android para padrões comuns reais.

Extensões práticas: auxiliares de Context, View e String é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Extensões no mundo real

As extensões são excelentes para tipos de frameworks que não podem ser modificados: Context, View, String e coleções. A seguir, veja padrões práticos diretamente de bases de código Android de produção.

Auxiliar Context.toast

Encapsule o código extenso Toast.makeText(...).show() em uma extensão de uma linha.

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!")

Auxiliares de recursos de Context

Evite conversões de tipo nas buscas de recursos. As extensões melhoram a legibilidade e a segurança de tipos.

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

Alterne entre View.VISIBLE e View.GONE sem complicações.

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)

Uma função de uma linha que alterna com base em uma condição — substitui o código de visibilidade com 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 de View.onClick

O ouvinte de cliques fica mais limpo — passe uma lambda em vez de um OnClickListener anônimo.

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

String.isValidEmail

Extensões de validação específicas do domínio em String tornam a lógica de negócio mais legível.

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

Trunque strings longas com reticências — um auxiliar comum de interface.

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

Coloque cada palavra em maiúscula — um auxiliar comum de formatação.

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())
}

Extensão de lista: chunkedBy

Agrupe elementos consecutivos por uma chave — útil para seções da interface.

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]]
}

Auxiliares de Activity

Torne a navegação segura em relação aos tipos e mais curta com genéricos reificados.

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

Não exagere

As extensões são adicionadas ao espaço de nomes global. Mantenha-as focadas, com escopo definido (private/internal) e agrupadas por domínio (um arquivo por tipo receptor funciona bem).

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

Verificação rápida

Por que as extensões são ideais para tipos de frameworks Android, como Context ou View?

Recapitulação

As extensões são perfeitas para adicionar auxiliares ergonômicos a tipos de frameworks (Context, View, String, lista). Padrões comuns: alternância de visibilidade, ouvintes de cliques, buscas de recursos, validação e formatação. Mantenha as extensões focadas, com escopo definido e agrupadas por tipo receptor.

Perguntas Frequentes

A aula “Extensões práticas: auxiliares de Context, View e String” é grátis?

Sim — o texto completo de “Extensões práticas: auxiliares de Context, View e String” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Extensões práticas: auxiliares de Context, View e String”?

Crie extensões utilitárias no estilo Android para padrões comuns reais. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Extensões práticas: auxiliares de Context, View e String”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Funções de extensão: sintaxe e regras de despacho
  2. Propriedades de extensão e extensões calculadas
  3. Extensões com escopo e extensões de companion
  4. Extensões práticas: auxiliares de Context, View e String
← Voltar para Kotlin Academy