Clean Code em Kotlin: princípios e exemplos para código limpo

Clean Code em Kotlin: princípios e exemplos para código limpo

Código limpo não é apenas um termo da moda, mas uma habilidade fundamental para um desenvolvedor profissional. Quando você escreve em Kotlin, uma linguagem moderna e expressiva, os princípios do Clean Code se tornam ainda mais relevantes. Código que é fácil de ler, modificar e manter economiza horas de depuração e facilita a vida de toda a equipe. Neste artigo, vamos explorar os principais princípios do Clean Code em Kotlin com exemplos concretos que ajudarão você a escrever código elegante e confiável.

1. Nomenclatura: fale a linguagem do domínio

A nomenclatura correta é a base do código limpo. Nomes de variáveis, funções e classes devem responder imediatamente às perguntas "o que é isso?" e "para que serve?". Evite abreviações de uma letra e nomes abstratos como data ou temp.

Exemplo ruim:

val d = mutableListOf<String>()fun prc(u: User) {    d.add(u.name)    if (u.age > 18) println(u.name)}

Exemplo bom:

val registeredUserNames = mutableListOf<String>()

fun printAdultUserName(user: User) {    registeredUserNames.add(user.name)    if (user.isAdult()) {        println(user.name)    }}

No exemplo bom, fica imediatamente claro o que a função faz e quais dados estão armazenados na lista. Use substantivos para classes (UserRepository), verbos para funções (processOrder) e predicados booleanos (isActive, hasPermission).

2. Funções: pequenas, de tarefa única e sem efeitos colaterais

Uma das principais ideias do Clean Code é que uma função deve fazer apenas uma coisa. Se uma função exceder 15-20 linhas, provavelmente precisa ser dividida. Kotlin, com suas funções de extensão e lambdas, é excelente para isso.

Exemplo: dividindo uma função complexa

Suponha que temos uma função para processar um pedido:

fun processOrder(order: Order) {    // Validação    if (order.items.isEmpty()) throw IllegalArgumentException("Order must have items")    if (order.totalPrice < 0.0) throw IllegalArgumentException("Invalid price")        // Cálculo de desconto    var finalPrice = order.totalPrice    if (order.user.isPremium) {        finalPrice *= 0.9    }        // Envio de notificação    emailService.send(order.user.email, "Your order is confirmed")    smsService.send(order.user.phone, "Order #${order.id} confirmed")}

Refatoração seguindo os princípios do Clean Code:

fun processOrder(order: Order) {    validateOrder(order)    val finalPrice = calculateFinalPrice(order)    sendOrderConfirmation(order, finalPrice)}

private fun validateOrder(order: Order) {    require(order.items.isNotEmpty()) { "Order must have items" }    require(order.totalPrice >= 0.0) { "Invalid price" }}

private fun calculateFinalPrice(order: Order): Double {    return if (order.user.isPremium) order.totalPrice * 0.9 else order.totalPrice}

private fun sendOrderConfirmation(order: Order, finalPrice: Double) {    val message = "Order #${order.id} confirmed. Total: $finalPrice"    notificationService.notifyUser(order.user, message)}

Agora cada função é responsável por uma única tarefa, são fáceis de testar e reutilizar.

3. Null Safety: use os recursos do Kotlin

Um dos principais destaques do Kotlin é a null safety. Clean Code em Kotlin implica eliminar completamente o null sempre que possível. Evite o uso de !! (not-null assertion) — isso é quase sempre um sinal de design ruim.

Exemplo ruim:

fun getUserName(userId: String): String {    val user = userRepository.findById(userId)!!    return user.name!!}

Exemplo bom:

fun getUserName(userId: String): String? {    val user = userRepository.findById(userId)    return user?.name}

No exemplo bom, usamos operadores seguros (?.) e tipos anuláveis de forma explícita, tornando o código mais seguro e legível.