Kotlin Academy · Lezione

Buone pratiche

Mantenga intuitivi gli operatori

Buone pratiche è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Mantenga intuitivi gli operatori

Sovraccarichi un operatore solo quando il suo significato è evidente. + sui vettori è chiaro; + con il significato di inviare un'e-mail non lo è.

data class Vec(val x: Int, val y: Int) {
    operator fun plus(o: Vec) = Vec(x + o.x, y + o.y)
}

fun main() {
    println(Vec(1, 2) + Vec(3, 4))
}

Preservi la semantica prevista

Rispetti l'algebra consueta: a + b dovrebbe avere un comportamento commutativo per i tipi simmetrici e non sorprendere chi legge.

data class Money(val cents: Int) {
    operator fun plus(o: Money) = Money(cents + o.cents)
}

fun main() {
    println(Money(100) + Money(50))
}

Preferisca l'immutabilità

Operatori come plus dovrebbero restituire un valore nuovo invece di modificare il ricevitore, in modo analogo al comportamento dei numeri.

data class Point(val x: Int) {
    operator fun plus(o: Point) = Point(x + o.x)
}

fun main() {
    val a = Point(1)
    val b = a + Point(2)
    println("${a.x} ${b.x}")
}

plus e plusAssign

Definisca plus per i valori immutabili e plusAssign per modificare direttamente i contenitori mutabili. Eviti di definirli entrambi con comportamenti in conflitto.

class Cart {
    val items = mutableListOf<String>()
    operator fun plusAssign(item: String) { items.add(item) }
}

fun main() {
    val c = Cart()
    c += "book"
    println(c.items)
}

Abbini i tipi restituiti

Restituisca lo stesso tipo dagli operatori binari, così i risultati possono essere concatenati naturalmente.

data class N(val v: Int) {
    operator fun plus(o: N) = N(v + o.v)
}

fun main() {
    println((N(1) + N(2) + N(3)).v)
}

Non sovraccarichi per puro virtuosismo

Se una funzione con nome risulta più chiara, la utilizzi. Gli operatori servono per semantiche realmente numeriche o simili a contenitori, non per creare enigmi.

data class Log(val lines: List<String>) {
    fun append(line: String) = Log(lines + line)
}

fun main() {
    println(Log(emptyList()).append("start").lines)
}

Mantenga coerenti equals e hashCode

Se sovraccarica il confronto o l'uguaglianza, mantenga sincronizzati equals e hashCode per evitare problemi nelle raccolte.

data class Id(val v: Int)

fun main() {
    val set = hashSetOf(Id(1), Id(1))
    println(set.size)
}

Presti attenzione alla precedenza degli operatori

Gli operatori sovraccaricati mantengono la precedenza predefinita. Progetti in modo che la precedenza naturale produca i risultati previsti.

data class N(val v: Int) {
    operator fun plus(o: N) = N(v + o.v)
    operator fun times(o: N) = N(v * o.v)
}

fun main() {
    println((N(2) + N(3) * N(4)).v)
}

Documenti gli operatori sorprendenti

Se un operatore esegue qualcosa di non ovvio, aggiunga un commento o un KDoc, così chi lo utilizza non viene indotto in errore.

data class Range2(val start: Int, val end: Int) {
    // contains: is value inside the range?
    operator fun contains(v: Int) = v in start..end
}

fun main() {
    println(5 in Range2(1, 10))
}

Utilizzi contains per in

L'operatore in corrisponde a contains. Lo sovrascriva solo quando l'appartenenza è ben definita per il Suo tipo.

class Team(val members: List<String>) {
    operator fun contains(name: String) = name in members
}

fun main() {
    val t = Team(listOf("Ann", "Bo"))
    println("Ann" in t)
}

Nel dubbio, utilizzi una funzione

Un metodo con un nome chiaro è quasi sempre più sicuro di un operatore oscuro. Riservi il sovraccarico ai casi in cui migliora davvero la leggibilità.

data class Temperature(val c: Int) {
    fun warmerThan(o: Temperature) = c > o.c
}

fun main() {
    println(Temperature(30).warmerThan(Temperature(20)))
}

Verifica rapida

Verifichi la Sua comprensione delle procedure consigliate per il sovraccarico degli operatori.

Riepilogo

Ha imparato le procedure consigliate per il sovraccarico degli operatori:

Sovraccarichi gli operatori solo quando il significato è evidente e convenzionale.
Preferisca valori immutabili e restituiti dello stesso tipo; mantenga i risultati concatenabili.
Separi plus (valore) da plusAssign (modifica).
Mantenga coerenti equals/hashCode; preferisca le funzioni con nome quando sono più chiare.

data class V(val x: Int) {
    operator fun plus(o: V) = V(x + o.x)
}

fun main() {
    println((V(2) + V(5)).x)
}

Domande Frequenti

La lezione «Buone pratiche» è gratuita?

Sì — il testo completo di «Buone pratiche» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Buone pratiche»?

Mantenga intuitivi gli operatori Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Buone pratiche»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy