Buenas prácticas
Mantenga intuitivos los operadores
Buenas prácticas es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.
Mantenga intuitivos los operadores
Defina la sobrecarga de un operador solo cuando su significado sea obvio. + aplicado a vectores es claro; + con el significado de enviar un correo electrónico no lo es.
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))
}Respete la semántica esperada
Respete el álgebra habitual: a + b debería dar una sensación de conmutatividad en tipos simétricos y no sorprender a quienes leen el código.
data class Money(val cents: Int) {
operator fun plus(o: Money) = Money(cents + o.cents)
}
fun main() {
println(Money(100) + Money(50))
}Prefiera la inmutabilidad
Los operadores como plus deberían devolver un valor nuevo en lugar de modificar el receptor, de acuerdo con el comportamiento de los números.
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 frente a plusAssign
Defina plus para valores inmutables y plusAssign para modificar contenedores mutables en el sitio. Evite definir ambos con comportamientos contradictorios.
class Cart {
val items = mutableListOf<String>()
operator fun plusAssign(item: String) { items.add(item) }
}
fun main() {
val c = Cart()
c += "book"
println(c.items)
}Haga coincidir los tipos de retorno
Devuelva el mismo tipo en los operadores binarios para que los resultados se puedan encadenar de forma natural.
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)
}No sobrecargue por ingenio
Si una función con nombre se entiende mejor, utilícela. Los operadores son para semánticas realmente numéricas o similares a las de los contenedores, no para crear acertijos.
data class Log(val lines: List<String>) {
fun append(line: String) = Log(lines + line)
}
fun main() {
println(Log(emptyList()).append("start").lines)
}Mantenga equals y hashCode coherentes
Si sobrecarga la comparación o la igualdad, mantenga equals y hashCode sincronizados para evitar que las colecciones dejen de funcionar correctamente.
data class Id(val v: Int)
fun main() {
val set = hashSetOf(Id(1), Id(1))
println(set.size)
}Tenga en cuenta la precedencia de los operadores
Los operadores sobrecargados conservan la precedencia integrada. Diseñe el código de modo que la precedencia natural produzca los resultados esperados.
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)
}Documente los operadores inesperados
Si un operador hace algo que no resulta obvio, añada un comentario o KDoc para no inducir a error a quienes lo utilicen.
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))
}Use contains para in
El operador in corresponde a contains. Sobrescríbalo solo cuando la pertenencia esté bien definida para su 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)
}En caso de duda, use una función
Un método con un nombre claro casi siempre es más seguro que un operador poco evidente. Reserve la sobrecarga para los casos en que realmente mejore la legibilidad.
data class Temperature(val c: Int) {
fun warmerThan(o: Temperature) = c > o.c
}
fun main() {
println(Temperature(30).warmerThan(Temperature(20)))
}Comprobación rápida
Compruebe su comprensión de las buenas prácticas para la sobrecarga de operadores.
Resumen
Ha aprendido las buenas prácticas para sobrecargar operadores:
- Sobrecargue solo cuando el significado sea obvio y convencional.
- Prefiera retornos inmutables del mismo tipo y mantenga los resultados encadenables.
- Separe
plus(valor) deplusAssign(modificación). - Mantenga coherentes
equalsyhashCode; prefiera funciones con nombre cuando sean más claras.
data class V(val x: Int) {
operator fun plus(o: V) = V(x + o.x)
}
fun main() {
println((V(2) + V(5)).x)
}Preguntas frecuentes
¿La lección «Buenas prácticas» es gratis?
Sí — el texto completo de «Buenas prácticas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Buenas prácticas»?
Mantenga intuitivos los operadores Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Kotlin Academy?
No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Buenas prácticas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?
Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.