Sentencia when en Kotlin

En Kotlin, la sentencia when se utiliza para tomar decisiones basadas en el valor de una expresión. La sintaxis básica de la sentencia when es la siguiente:

when (expresion) {
    valor1 -> {
        // Código a ejecutar si la expresión es igual a valor1
    }
    valor2 -> {
        // Código a ejecutar si la expresión es igual a valor2
    }
    valor3 -> {
        // Código a ejecutar si la expresión es igual a valor3
    }
    else -> {
        // Código a ejecutar si la expresión no coincide con ningún valor
    }
}

En este caso, la sentencia when evalúa la expresión y ejecuta el bloque de código correspondiente al valor que coincide con la expresión. Si la expresión no coincide con ningún valor, se ejecuta el bloque de código dentro de la cláusula else.

Ejemplo de sentencia when

A continuación se muestra un ejemplo de cómo utilizar la sentencia when en Kotlin:

// Función que imprime el día de la semana

fun imprimirDiaSemana(dia: Int) {
    when (dia) {
        1 -> println("Lunes")
        2 -> println("Martes")
        3 -> println("Miércoles")
        4 -> println("Jueves")
        5 -> println("Viernes")
        6 -> println("Sábado")
        7 -> println("Domingo")
        else -> println("Día inválido")
    }
}

fun main() {
    imprimirDiaSemana(1)
    imprimirDiaSemana(4)
    imprimirDiaSemana(7)
    imprimirDiaSemana(9)
}

En este caso, la función imprimirDiaSemana toma un parámetro dia y utiliza la sentencia when para imprimir el día de la semana correspondiente al valor del parámetro. Si el valor del parámetro no coincide con ningún día de la semana, se imprime “Día inválido”.

La sentencia when es una forma concisa y legible de tomar decisiones basadas en el valor de una expresión en Kotlin. Utiliza la sentencia when para simplificar la lógica de tus programas y mejorar su mantenibilidad.

Ahora vamos a programar otros ejemplos para practicar el uso de la sentencia when en Kotlin.

// Crear una función que determine el tipo de día (laboral o festivo)

fun determinarTipoDia(dia: String) {
    when (dia) {
        "Lunes", "Martes", "Miércoles", "Jueves", "Viernes" -> println("Día laboral")
        "Sábado", "Domingo" -> println("Día festivo")
        else -> println("Día inválido")
    }
}

fun main() {
    determinarTipoDia("Lunes") // Día laboral
    determinarTipoDia("Sábado") // Día festivo
    determinarTipoDia("Miércoles") // Día laboral
    determinarTipoDia("Viernes") // Día laboral
    determinarTipoDia("Domingo") // Día festivo
    determinarTipoDia("Martes") // Día laboral
    determinarTipoDia("Jueves") // Día laboral
    determinarTipoDia("Vacaciones") // Día inválido
}

En este caso, la función determinarTipoDia toma un parámetro dia y utiliza la sentencia when para determinar si es un día laboral, festivo o inválido en función del valor del parámetro.

La sentencia when es una herramienta poderosa que te permite tomar decisiones basadas en el valor de una expresión de forma concisa y legible en Kotlin. Utiliza la sentencia when para simplificar la lógica de tus programas y mejorar su mantenibilidad.

// Crear una función que determine el tipo de triángulo (equilátero, isósceles o escaleno)

fun determinarTipoTriangulo(lado1: Int, lado2: Int, lado3: Int) {
    when {
        lado1 == lado2 && lado2 == lado3 -> println("Triángulo equilátero")
        lado1 == lado2 || lado2 == lado3 || lado1 == lado3 -> println("Triángulo isósceles")
        else -> println("Triángulo escaleno")
    }
}

fun main() {
    determinarTipoTriangulo(5, 5, 5) // Triángulo equilátero
    determinarTipoTriangulo(3, 4, 3) // Triángulo isósceles
    determinarTipoTriangulo(7, 4, 5) // Triángulo escaleno
}

En este caso, la función determinarTipoTriangulo toma tres parámetros lado1, lado2 y lado3 que representan los lados de un triángulo y utiliza la sentencia when para determinar si es equilátero, isósceles o escaleno en función de las longitudes de los lados.

La sentencia when es una forma concisa y legible de tomar decisiones basadas en múltiples condiciones en Kotlin. Utiliza la sentencia when para simplificar la lógica de tus programas y mejorar su mantenibilidad.

// Crear una función que determine el horario de una tienda

fun determinarHorario(tiempo: Int) {
    when (tiempo) {
        in 0..6 -> println("La tienda está cerrada")
        in 7..12 -> println("La tienda está abierta por la mañana")
        in 13..18 -> println("La tienda está abierta por la tarde")
        in 19..23 -> println("La tienda está abierta por la noche")
        else -> println("Hora inválida")
    }
}

fun main() {
    determinarHorario(5) // La tienda está cerrada
    determinarHorario(10) // La tienda está abierta por la mañana
    determinarHorario(15) // La tienda está abierta por la tarde
    determinarHorario(20) // La tienda está abierta por la noche
    determinarHorario(25) // Hora inválida
}

En este caso, la función determinarHorario toma un parámetro tiempo que representa la hora del día y utiliza la sentencia when para determinar el horario de la tienda en función de la hora del día.

La sentencia when es una herramienta poderosa que te permite tomar decisiones basadas en rangos de valores en Kotlin. Utiliza la sentencia when para simplificar la lógica de tus programas y mejorar su mantenibilidad.

// Crear una función que determine el signo zodiacal

fun determinarSignoZodiacal(dia: Int, mes: Int) {
    when {
        (mes == 3 && dia >= 21) || (mes == 4 && dia <= 19) -> println("Aries")
        (mes == 4 && dia >= 20) || (mes == 5 && dia <= 20) -> println("Tauro")
        (mes == 5 && dia >= 21) || (mes == 6 && dia <= 20) -> println("Géminis")
        (mes == 6 && dia >= 21) || (mes == 7 && dia <= 22) -> println("Cáncer")
        (mes == 7 && dia >= 23) || (mes == 8 && dia <= 22) -> println("Leo")
        (mes == 8 && dia >= 23) || (mes == 9 && dia <= 22) -> println("Virgo")
        (mes == 9 && dia >= 23) || (mes == 10 && dia <= 22) -> println("Libra")
        (mes == 10 && dia >= 23) || (mes == 11 && dia <= 21) -> println("Escorpio")
        (mes == 11 && dia >= 22) || (mes == 12 && dia <= 21) -> println("Sagitario")
        (mes == 12 && dia >= 22) || (mes == 1 && dia <= 19) -> println("Capricornio")
        (mes == 1 && dia >= 20) || (mes == 2 && dia <= 18) -> println("Acuario")
        (mes == 2 && dia >= 19) || (mes == 3 && dia <= 20) -> println("Piscis")
        else -> println("Fecha inválida")
    }
}

fun main() {
    determinarSignoZodiacal(21, 3) // Aries
    determinarSignoZodiacal(20, 4) // Tauro
    determinarSignoZodiacal(21, 6) // Géminis
    determinarSignoZodiacal(23, 7) // Leo
    determinarSignoZodiacal(22, 8) // Virgo
    determinarSignoZodiacal(22, 12) // Capricornio
    determinarSignoZodiacal(19, 1) // Capricornio
    determinarSignoZodiacal(20, 1) // Acuario
    determinarSignoZodiacal(18, 2) // Acuario
    determinarSignoZodiacal(19, 2) // Piscis
    determinarSignoZodiacal(20, 3) // Piscis
    determinarSignoZodiacal(32, 13) // Fecha inválida
}

En este caso, la función determinarSignoZodiacal toma dos parámetros dia y mes que representan la fecha de nacimiento de una persona y utiliza la sentencia when para determinar su signo zodiacal en función de la fecha de nacimiento.

La sentencia when es una forma concisa y legible de tomar decisiones basadas en múltiples condiciones en Kotlin. Utiliza la sentencia when para simplificar la lógica de tus programas y mejorar su mantenibilidad.

¡Excelente! Ahora sabes cómo utilizar la sentencia when en Kotlin para tomar decisiones basadas en el valor de una expresión. Utiliza la sentencia when para simplificar la lógica de tus programas y mejorar su mantenibilidad.