El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, aprenderemos sobre las mejores prácticas y convenciones de estilo de código en Kotlin. Seguir estas convenciones no solo hace que tu código sea más legible y mantenible, sino que también facilita la colaboración con otros desarrolladores.

Convenciones de Nomenclatura

1.1. Nombres de Clases y Objetos

Clases y Objetos: Usa el estilo PascalCase.
```
class MyClass
object MyObject
```

1.2. Nombres de Métodos y Variables

Métodos y Variables: Usa el estilo camelCase.
```
fun calculateSum() { }
val userName: String
```

1.3. Constantes y Propiedades Inmutables

Constantes: Usa mayúsculas y guiones bajos.
```
const val MAX_COUNT = 100
```

Formato de Código

2.1. Sangría

Usa 4 espacios para la sangría. No uses tabulaciones.

fun exampleFunction() {
    val x = 10
    if (x > 5) {
        println("x is greater than 5")
    }
}

2.2. Longitud de Línea

Mantén las líneas de código a un máximo de 100 caracteres.

2.3. Espacios en Blanco

Usa espacios en blanco para mejorar la legibilidad.
```
val sum = a + b
```

Organización del Código

3.1. Orden de Declaraciones

Sigue este orden para las declaraciones dentro de una clase:

Propiedades
Constructores
Métodos

class Example {
    val property: String

    constructor(property: String) {
        this.property = property
    }

    fun method() { }
}

3.2. Importaciones

Organiza las importaciones de manera lógica y evita las importaciones de comodines (*).

Documentación

4.1. Comentarios

Usa comentarios para explicar el "por qué" detrás del código, no el "qué".

// Calcula la suma de dos números
fun calculateSum(a: Int, b: Int): Int {
    return a + b
}

4.2. KDoc

Usa KDoc para documentar clases, métodos y propiedades.

/**
 * Representa un usuario en el sistema.
 *
 * @property name El nombre del usuario.
 * @property age La edad del usuario.
 */
class User(val name: String, val age: Int)

Ejemplo Práctico

Vamos a ver un ejemplo práctico que sigue las convenciones de estilo de código en Kotlin.

/**
 * Representa un producto en una tienda.
 *
 * @property name El nombre del producto.
 * @property price El precio del producto.
 */
class Product(val name: String, val price: Double) {

    /**
     * Calcula el precio con descuento.
     *
     * @param discount El porcentaje de descuento.
     * @return El precio con el descuento aplicado.
     */
    fun calculateDiscountedPrice(discount: Double): Double {
        return price - (price * discount / 100)
    }
}

fun main() {
    val product = Product("Laptop", 1500.0)
    val discountedPrice = product.calculateDiscountedPrice(10.0)
    println("Precio con descuento: $discountedPrice")
}

Ejercicio Práctico

Ejercicio

Crea una clase Employee que tenga las siguientes propiedades y métodos:

Propiedades: name (String), salary (Double)
Método: calculateAnnualSalary que devuelve el salario anual del empleado.

Solución

/**
 * Representa un empleado en una empresa.
 *
 * @property name El nombre del empleado.
 * @property salary El salario mensual del empleado.
 */
class Employee(val name: String, val salary: Double) {

    /**
     * Calcula el salario anual del empleado.
     *
     * @return El salario anual.
     */
    fun calculateAnnualSalary(): Double {
        return salary * 12
    }
}

fun main() {
    val employee = Employee("John Doe", 3000.0)
    val annualSalary = employee.calculateAnnualSalary()
    println("Salario anual: $annualSalary")
}

Conclusión

En esta sección, hemos cubierto las convenciones de estilo de código en Kotlin, incluyendo la nomenclatura, el formato de código, la organización del código y la documentación. Seguir estas convenciones te ayudará a escribir código más limpio y mantenible, y facilitará la colaboración con otros desarrolladores. En el próximo tema, exploraremos la optimización del rendimiento en Kotlin.

Estilo de Código y Convenciones