Aprende Kotlin desde cero

fun main() {
    println("¡Hola, mundo!")
    println(2 + 3) // 5
}

fun main() {
    val nombre = "Ana"
    var edad = 30
    edad += 1
    val precio: Double = 19.99

    println("$nombre tiene $edad años")
    println("Total: ${"%.2f".format(precio * 3)}")
    // nombre = "Eva"  // error: val cannot be reassigned
}

fun main() {
    val nota = 7
    val resultado = when (nota) {
        in 9..10 -> "Sobresaliente"
        in 5..8 -> "Aprobado"
        else -> "Suspenso"
    }
    println(resultado) // Aprobado

    val acceso = if (nota >= 5) "permitido" else "denegado"
    println(acceso)
}

fun main() {
    val compra = mutableListOf("pan", "leche")
    compra.add("huevos")
    for (producto in compra) println("- $producto")

    val stock = mapOf("teclado" to 10, "raton" to 0)
    println(stock["teclado"])     // 10
    println(stock.size)           // 2
}

fun precioFinal(precio: Double, iva: Double = 21.0): Double =
    precio * (1 + iva / 100)

fun main() {
    println(precioFinal(100.0))              // 121.0
    println(precioFinal(100.0, iva = 10.0))  // 110.00000000000001
}

fun main() {
    val apodo: String? = null
    println(apodo?.uppercase() ?: "Sin apodo")   // Sin apodo

    val nombre: String = "Ana"
    println(nombre.length)                        // 3

    // println(apodo.length)  // error de compilación: apodo puede ser null, hay que usar ?. o !!
}

class Cuenta(val titular: String) {
    var saldo = 0.0
        private set

    fun ingresar(cantidad: Double) {
        require(cantidad > 0) { "La cantidad debe ser positiva" }
        saldo += cantidad
    }
}

data class Producto(val nombre: String, val precio: Double)

fun main() {
    val c = Cuenta("Ana")
    c.ingresar(50.0)
    println(c.saldo)                          // 50.0

    val raton = Producto("Ratón", 12.5)
    println(raton.copy(precio = 9.99))        // Producto(nombre=Ratón, precio=9.99)
}

data class Producto(val nombre: String, val precio: Double)

fun main() {
    val productos = listOf(
        Producto("Teclado", 25.9),
        Producto("Ratón", 12.5),
        Producto("Cable", 4.99),
    )
    val caros = productos.filter { it.precio > 10 }.map { it.nombre }.sorted()
    println(caros)                                         // [Ratón, Teclado]
    println("%.2f".format(productos.sumOf { it.precio }))  // 43,39 o 43.39 según el idioma del sistema
}

sealed interface Resultado
data class Exito(val datos: String) : Resultado
data class Fallo(val mensaje: String) : Resultado

fun describir(r: Resultado): String = when (r) {
    is Exito -> "Recibido: ${r.datos}"
    is Fallo -> "Error: ${r.mensaje}"
}

fun main() {
    println(describir(Exito("3 pedidos")))
    println(describir(Fallo("sin conexión")))
}

// Requiere la dependencia org.jetbrains.kotlinx:kotlinx-coroutines-core
import kotlinx.coroutines.*

suspend fun descargar(nombre: String): String {
    delay(500)            // simula esperar a la red sin bloquear
    return "datos de $nombre"
}

fun main() = runBlocking {
    val a = async { descargar("pedidos") }
    val b = async { descargar("clientes") }
    println(a.await())
    println(b.await())    // las dos descargas han ido a la vez: unos 0,5 s en total
}

fun String.iniciales(): String =
    split(" ").filter { it.isNotBlank() }.joinToString("") { it.first().uppercase() }

fun Double.euros(): String = "%.2f €".format(this)

fun main() {
    println("ana maría lópez".iniciales())   // AML
    println(19.5.euros())                    // 19,50 € (con el sistema en español)
}

fun leerEdad(texto: String): Int {
    val edad = texto.trim().toInt()               // lanza NumberFormatException si no es un número
    require(edad in 0..130) { "Edad fuera de rango: $edad" }
    return edad
}

fun main() {
    println(runCatching { leerEdad("42") }.getOrDefault(-1))    // 42
    println(runCatching { leerEdad("abc") }.getOrDefault(-1))   // -1

    runCatching { leerEdad("200") }
        .onSuccess { println("Edad válida: $it") }
        .onFailure { println("No válida: ${it.message}") }      // No válida: Edad fuera de rango: 200
}

data class Venta(val vendedor: String, val mes: Int, val importe: Double)

fun main() {
    val ventas = listOf(
        Venta("Ana", 1, 300.0), Venta("Luis", 1, 500.0),
        Venta("Ana", 2, 450.0), Venta("Luis", 2, 200.0),
    )

    val porVendedor = ventas.groupBy { it.vendedor }.mapValues { (_, v) -> v.sumOf { it.importe } }
    println(porVendedor)                                  // {Ana=750.0, Luis=700.0}

    println(ventas.maxByOrNull { it.importe }?.vendedor)  // Luis
    println(ventas.count { it.importe > 400 })            // 2
    println(ventas.associate { "${it.vendedor}-${it.mes}" to it.importe }["Ana-2"])  // 450.0
}

object Contador {
    private var visitas = 0
    fun registrar(): Int = ++visitas
}

class Temperatura private constructor(val celsius: Double) {
    companion object {
        const val CERO_ABSOLUTO = -273.15
        fun desdeFahrenheit(f: Double) = Temperatura((f - 32) * 5 / 9)
    }
}

fun main() {
    Contador.registrar()
    println(Contador.registrar())                            // 2

    val t = Temperatura.desdeFahrenheit(212.0)
    println(t.celsius)                                       // 100.0
    println(Temperatura.CERO_ABSOLUTO)                       // -273.15
}

import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith

fun dividir(a: Int, b: Int): Int {
    require(b != 0) { "No se puede dividir entre 0" }
    return a / b
}

class CalculadoraTest {
    @Test
    fun divideNumerosExactos() {
        assertEquals(4, dividir(12, 3))
    }

    @Test
    fun entreCeroFalla() {
        assertFailsWith<IllegalArgumentException> { dividir(5, 0) }
    }
}