Bonnes pratiques
Conserver des opérateurs intuitifs
Bonnes pratiques est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Garder des opérateurs intuitifs
Ne surchargez un opérateur que lorsque sa signification est évidente. Utiliser + sur des vecteurs est clair ; lui donner le sens « envoyer un e-mail » ne l'est pas.
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))
}Préserver la sémantique attendue
Respectez l'algèbre habituelle : a + b devrait sembler commutatif pour les types symétriques et ne devrait pas surprendre les lecteurs.
data class Money(val cents: Int) {
operator fun plus(o: Money) = Money(cents + o.cents)
}
fun main() {
println(Money(100) + Money(50))
}Privilégier l'immuabilité
Les opérateurs tels que plus devraient renvoyer une valeur nouvelle plutôt que modifier le récepteur, comme le font les nombres.
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 ou plusAssign
Définissez plus pour les valeurs immuables ; définissez plusAssign pour modifier sur place des conteneurs mutables. Évitez de définir les deux avec des comportements contradictoires.
class Cart {
val items = mutableListOf<String>()
operator fun plusAssign(item: String) { items.add(item) }
}
fun main() {
val c = Cart()
c += "book"
println(c.items)
}Respecter les types de retour
Renvoyez le même type avec les opérateurs binaires afin que les résultats puissent naturellement s'enchaîner.
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)
}Ne surchargez pas pour faire preuve d'ingéniosité
Si une fonction nommée est plus lisible, utilisez-la. Les opérateurs servent à exprimer une sémantique réellement numérique ou analogue à celle d'un conteneur, pas à créer des énigmes.
data class Log(val lines: List<String>) {
fun append(line: String) = Log(lines + line)
}
fun main() {
println(Log(emptyList()).append("start").lines)
}Garder equals et hashCode cohérents
Si vous surchargez la comparaison ou l'égalité, gardez equals et hashCode cohérents afin d'éviter de rendre les collections défaillantes.
data class Id(val v: Int)
fun main() {
val set = hashSetOf(Id(1), Id(1))
println(set.size)
}Surveiller la priorité des opérateurs
Les opérateurs surchargés conservent la priorité intégrée au langage. Concevez-les de sorte que cette priorité naturelle produise les résultats attendus.
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)
}Documenter les opérateurs surprenants
Si un opérateur effectue quelque chose de non évident, ajoutez un commentaire ou une KDoc afin de ne pas induire les appelants en erreur.
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))
}Utiliser contains pour in
L'opérateur in correspond à contains. Ne le redéfinissez que si l'appartenance est bien définie pour votre type.
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)
}En cas de doute, utilisez une fonction
Une méthode clairement nommée est presque toujours plus sûre qu'un opérateur obscur. Réservez la surcharge aux cas où elle améliore réellement la lisibilité.
data class Temperature(val c: Int) {
fun warmerThan(o: Temperature) = c > o.c
}
fun main() {
println(Temperature(30).warmerThan(Temperature(20)))
}Vérification rapide
Vérifiez votre compréhension des bonnes pratiques de surcharge des opérateurs.
Récapitulatif
Vous avez appris les bonnes pratiques de surcharge des opérateurs :
- Ne surchargez un opérateur que lorsque sa signification est évidente et conforme aux conventions.
- Privilégiez des retours immuables du même type ; gardez les résultats chaînables.
- Séparez
plus(valeur) deplusAssign(modification). - Gardez
equalsethashCodecohérents ; préférez les fonctions nommées lorsqu'elles sont plus claires.
data class V(val x: Int) {
operator fun plus(o: V) = V(x + o.x)
}
fun main() {
println((V(2) + V(5)).x)
}Questions Fréquemment Posées
La leçon « Bonnes pratiques » est-elle gratuite ?
Oui — le texte complet de « Bonnes pratiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Bonnes pratiques » ?
Conserver des opérateurs intuitifs Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Bonnes pratiques » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?
Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.