Funcionalidades avanzadas en Kotlin: Menús y manejo de respuestas

Contenido del curso

Introducción a Kotlin

Configuración del entorno

Hola mundo Kotlin

Conceptos básicos de Kotlin

Collections en Kotlin

Libera el potencial de las funciones

Scope functions

Proyecto: Bola 8 mágica

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0015:08

Funcionalidades avanzadas en Kotlin: Menús y manejo de respuestas

Curso de Kotlin desde Cero

Clase 37 de 38

Clase 37 / 38

Recursos

¿Cómo continuar el proyecto en Kotlin?

En el vídeo anterior, ya hemos cubierto la mitad de nuestro proyecto en Kotlin. Hemos creado las constantes, mapas para las respuestas y diseñado un menú interactivo para que el usuario ingrese sus opciones. Ahora, procederemos a asignarles funcionalidad a cada una de estas opciones en nuestro entorno de desarrollo IntelliJ, en particular, veremos cómo añadir funciones interactivas al juego para hacerlo mucho más completo y atractivo.

¿Cómo generar una respuesta aleatoria a una pregunta?

Creamos una función llamada realizarPregunta que le solicita al usuario su pregunta. Sin embargo, no almacenaremos esta pregunta. La idea es generar una respuesta aleatoria en base al mapa de respuestas que se encuentra en nuestro proyecto.

fun realizarPregunta() {
    println("¿Qué pregunta deseas realizar?")
    readLine()  // Capturamos la pregunta del usuario
    val respuestaGenerada = respuestas.keys.random()
    println("La respuesta a eso es: $respuestaGenerada")
}

¿Cómo mostrar las respuestas categorizadas por tipo?

Para ello, vamos a desarrollar una función que le permita al usuario elegir entre distintas categorías de respuestas. Creamos un nuevo menú y asignamos funciones específicas para mostrar cada categoría: afirmativas, dudosas y negativas.

fun mostrarRespuesta() {
    println(
        """
        Selecciona una opción:
        1. Revisar todas las respuestas
        2. Revisar solo las respuestas afirmativas
        3. Revisar solo las respuestas dudosas
        4. Revisar solo las respuestas negativas
        """.trimIndent()
    )

    when (readLine()?.toIntOrNull()) {
        1 -> mostrarRespuestasPorTipo()
        2 -> mostrarRespuestasPorTipo("afirmativa")
        3 -> mostrarRespuestasPorTipo("dudosa")
        4 -> mostrarRespuestasPorTipo("negativa")
        else -> println("Respuesta no válida. Adiós.")
    }
}

fun mostrarRespuestasPorTipo(tipoRespuesta: String = "todas") {
    when (tipoRespuesta) {
        "afirmativa" -> respuestas.filterValues { it == "afirmativa" }
        "dudosa" -> respuestas.filterValues { it == "dudosa" }
        "negativa" -> respuestas.filterValues { it == "negativa" }
        else -> respuestas
    }.keys.forEach { println(it) }
}

¿Qué hacer para finalizar el juego o manejar errores?

Implementaremos las funciones sencillas para terminar el programa y manejar errores en caso de que el usuario ingrese comandos no válidos.

fun salir() {
    println("Hasta luego.")
}

fun mostrarError() {
    println("Vaya, parece que has elegido una opción no válida. Intenta de nuevo.")
}

¿Cómo ejecutar y probar el programa en diferentes sistemas operativos?

El programa en Kotlin puede presentar un comportamiento algo distinto en Windows debido a un bug conocido en la terminal IntelliJ. Asegúrate de presionar 'Enter' para permitir la ejecución correcta de las diferentes opciones.

Para ejecutar el programa:

Haz clic en el botón verde para compilar y correr el programa.
Sigue las instrucciones en pantalla, prestando atención al comportamiento en Windows.

Reto final: Refactorización del código

He aquí un pequeño reto: refactoriza el código para evitar repetición en las funciones utilizando una variable externa. Investiga sobre el uso de funciones auxiliares y comparte tu resultado en los comentarios. ¡Nos encantaría ver cómo implementas esta optimización!

El aprendizaje continuo en Kotlin y la práctica constante son clave para dominar este lenguaje. ¡Sigue adelante y no te detengas en tu viaje de conocimiento!

Ricardo Ramírez

Hace 3 años

Bueno ya termine el reto, e hice algunas modificaciones extras:

Agregue la lógica para que solo se salga del app si la persona escoge la opción salir, de lo contrario se seguirán mostrando las opciones, use un do Wile
Cree una Array con las opciones de respuesta, así use este array para llamar la opción de respuestas que se quiera mostrar

val ``validOptions ``= ``listOf``<String>(``RESPUESTA_AFIRMATIVA``, ``RESPUESTA_NEGATIVA``, ``RESPUESTA_DUDOSA``)

when(opcionIngresada){ "1","2","3","4" -> ``mostrarRespuestaPorTipo``(tipoRespuesta = ``validOptions``[opcionIngresada.``toInt``()-1]) "5" -> ``main``() "6" -> ``salir``() else -> ``mostrarError``("Seleccionaste una opcion no valida.\n")

Extrage la implementaci;on de la función also en una función aparte para poder utilizarla varias veces y no repetir código.

fun mostrarRespuestaPorTipo(tipoRespuesta:String = "TODAS") { when(tipoRespuesta){ "TODAS" -> ``respuestas``.keys.``forEach ``{ respuesta -> ``println``(respuesta) } ``RESPUESTA_AFIRMATIVA``, ``RESPUESTA_NEGATIVA``, ``RESPUESTA_DUDOSA ``-> ``respuestaFiltrada``(filtro = tipoRespuesta) } }

fun respuestaFiltrada(filtro:String): Map<String, String> { return ``respuestas``.``filterValues ``{ value -> value == filtro} .``also ``{ respuestaFiltrada -> ``println``(respuestaFiltrada.keys) } }

Aca dejo todo el código:

package org.example

import kotlin.system.exitProcess

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

val validOptions = listOf<String>("TODAS", RESPUESTA_AFIRMATIVA, RESPUESTA_NEGATIVA, RESPUESTA_DUDOSA)



//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)
//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
fun main() {
    do {
        println("Hola, soy tu bola 8 magica, selecciona una de las opciones siguientes")
        println("1. Realizar una pregunta.")
        println("2. Revisar todas las respuestas.")
        println("3. Salir")

        val valorIngresado = readln()

        when (valorIngresado) {
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> salir()
            else -> mostrarError(msj = "Selecciona una opcion valida. \n")
        }
    }while (valorIngresado !="3")

}

fun mostrarError(msj:String = "") {
    println(msj)
}

fun salir() {
    println("Has salido de la aplicacion")
    exitProcess(-1)
}
/**
 * Funcion que muestra el menu de opciones para los difenrentes tipos de respuesta
 */
fun mostrarRespuestas() {
    do {
        println("Selecciona una opcion: ")
        println("1. Revisar todas las respuestas")
        println("2. Revisar solo las respuestas afirmativas")
        println("3. Revisar solo las respuestas negativas")
        println("4. Revisar solo las respuestas dudosas")
        println("5. Regresar")
        println("6. Salir")
        val opcionIngresada = readln()
        when(opcionIngresada){
            "1","2","3","4" -> mostrarRespuestaPorTipo(tipoRespuesta = validOptions[opcionIngresada.toInt()-1])
            "5" -> main()
            "6" -> salir()
            else -> mostrarError("Seleccionaste una opcion no valida.\n")
        }
    }while (opcionIngresada != "6")
}
/**
 * Funcion que captura la pregunta del usuario y genera una respuesta aleatoria
 */
fun realizarPregunta(){
    println("Que pregunta deseas realizar?")
    readln()
    println("Con que esas tenemos, tu respuesta es>")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)

}
/**
 * Funcion que devuelve la lista de respuestas dependiendo el tipo
 * @param tipoRespuesta  el tipo de respuesta seleccionada
 */
fun mostrarRespuestaPorTipo(tipoRespuesta:String = "TODAS") {
    when(tipoRespuesta){
        "TODAS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA, RESPUESTA_NEGATIVA, RESPUESTA_DUDOSA -> respuestaFiltrada(filtro = tipoRespuesta)
    }
}
/**
* Filtra las respuestas segun el tipo que llega como parametro
* @param filtro  valor a aplicar para filtrar la lista
*/
fun respuestaFiltrada(filtro:String): Map<String, String> {
    return respuestas.filterValues { value -> value == filtro}
        .also { respuestaFiltrada -> println(respuestaFiltrada.keys) }
}

```package org.example

import kotlin.system.exitProcess

// Declaramos los valores de nuestras respuestas
const val *RESPUESTA\_AFIRMATIVA* = "✅"
const val *RESPUESTA\_NEGATIVA* = "❌"
const val *RESPUESTA\_DUDOSA* = "\uD83E\uDD14"
val *validOptions* = *listOf*\<String>("TODAS", *RESPUESTA\_AFIRMATIVA*, *RESPUESTA\_NEGATIVA*, *RESPUESTA\_DUDOSA*)



//Unimos las respuestas con los valores
val *respuestas* = *mapOf*(
&#x20;   "Sí" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Es cierto" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Totalmente" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Sin duda" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Pregunta en otro momento" *to RESPUESTA\_DUDOSA*,
&#x20;   "No puedo decirte en este momento" *to RESPUESTA\_DUDOSA*,
&#x20;   "Puede que si o puede que no" *to RESPUESTA\_DUDOSA*,
&#x20;   "No va a suceder" *to RESPUESTA\_NEGATIVA*,
&#x20;   "No cuentes con ello" *to RESPUESTA\_NEGATIVA*,
&#x20;   "Definitivamente no" *to RESPUESTA\_NEGATIVA*,
&#x20;   "No lo creo" *to RESPUESTA\_NEGATIVA*,
)
//TIP To \<b>Run\</b> code, press \<shortcut actionId="Run"/> or
// click the \<icon src="AllIcons.Actions.Execute"/> icon in the gutter.
fun main() {
&#x20;   do {
&#x20;       *println*("Hola, soy tu bola 8 magica, selecciona una de las opciones siguientes")
&#x20;       *println*("1. Realizar una pregunta.")
&#x20;       *println*("2. Revisar todas las respuestas.")
&#x20;       *println*("3. Salir")

&#x20;       val valorIngresado = *readln*()

&#x20;       when (valorIngresado) {
&#x20;           "1" -> *realizarPregunta*()
&#x20;           "2" -> *mostrarRespuestas*()
&#x20;           "3" -> *salir*()
&#x20;           else -> *mostrarError*(msj = "Selecciona una opcion valida. \n")
&#x20;       }
&#x20;   }while (valorIngresado !="3")

}

fun mostrarError(msj:String = "") {
&#x20;   *println*(msj)
}

fun salir() {
&#x20;   *println*("Has salido de la aplicacion")
&#x20;   *exitProcess*(-1)
}
*/\*\**
&#x20;*\* Funcion que muestra el menu de opciones para los difenrentes tipos de respuesta*
&#x20;*\*/*
fun mostrarRespuestas() {
&#x20;   do {
&#x20;       *println*("Selecciona una opcion: ")
&#x20;       *println*("1. Revisar todas las respuestas")
&#x20;       *println*("2. Revisar solo las respuestas afirmativas")
&#x20;       *println*("3. Revisar solo las respuestas negativas")
&#x20;       *println*("4. Revisar solo las respuestas dudosas")
&#x20;       *println*("5. Regresar")
&#x20;       *println*("6. Salir")
&#x20;       val opcionIngresada = *readln*()
&#x20;       when(opcionIngresada){
&#x20;           "1","2","3","4" -> *mostrarRespuestaPorTipo*(tipoRespuesta = *validOptions*\[opcionIngresada.*toInt*()-1])
&#x20;           "5" -> *main*()
&#x20;           "6" -> *salir*()
&#x20;           else -> *mostrarError*("Seleccionaste una opcion no valida.\n")
&#x20;       }
&#x20;   }while (opcionIngresada != "6")
}
*/\*\**
&#x20;*\* Funcion que captura la pregunta del usuario y genera una respuesta aleatoria*
&#x20;*\*/*
fun realizarPregunta(){
&#x20;   *println*("Que pregunta deseas realizar?")
&#x20;   *readln*()
&#x20;   *println*("Con que esas tenemos, tu respuesta es>")
&#x20;   val respuestaGenerada = *respuestas*.keys.*random*()
&#x20;   *println*(respuestaGenerada)

}
*/\*\**
&#x20;*\* Funcion que devuelve la lista de respuestas dependiendo el tipo*
&#x20;*\* @param tipoRespuesta  el tipo de respuesta seleccionada*
&#x20;*\*/*
fun mostrarRespuestaPorTipo(tipoRespuesta:String = "TODAS") {
&#x20;   when(tipoRespuesta){
&#x20;       "TODAS" -> *respuestas*.keys.*forEach* { respuesta -> *println*(respuesta) }
&#x20;       *RESPUESTA\_AFIRMATIVA*, *RESPUESTA\_NEGATIVA*, *RESPUESTA\_DUDOSA* -> *respuestaFiltrada*(filtro = tipoRespuesta)
&#x20;   }
}
*/\*\**
*\* Filtra las respuestas segun el tipo que llega como parametro*
*\* @param filtro  valor a aplicar para filtrar la lista*
*\*/*
fun respuestaFiltrada(filtro:String): Map\<String, String> {
&#x20;   return *respuestas*.*filterValues* { value -> value == filtro}
&#x20;       .*also* { respuestaFiltrada -> *println*(respuestaFiltrada.keys) }
}

Comentarios (64)64 comentarios

Daniel Hernández Sánchez

Hace 5 años

Gustavo Victoria Ramirez

Silvana Rolón

Jesus Orlando Carcamo Posada

Mario Peña

Ramiz Perez Ordoñez

Emanuel Agustín Serdeiro

Daniela Lara

Carlos Lopez

Hace 2 años

Juan Daniel Espinoza Cordova

Santiago Cardona Arango

Albert Toscano

Juan Camilo Molina pardo

Pedro Roberto Capriles Morales

Felipe Moreno

Alejandro Martinez

Nataly Jallo Arana

Kevin Parra Lopez

Hely Andrés Palencia

Introducción a Kotlin

¡Este curso ha sido actualizado!

Curso de Kotlin desde Cero para Desarrollo de Aplicaciones

Java Virtual Machine: Funcionamiento y Ventajas

Introducción a Kotlin y sus ventajas en desarrollo Android

Configuración del entorno

Instalación de IntelliJ IDEA Community Edition en Windows, Mac y Linux

Instalación de IntelliJ Idea Community en Linux

Configuración de Kotlin en Visual Studio Code

Hola mundo Kotlin

Estructura y Funcionalidad de Archivos en un Proyecto Kotlin

Variables en Kotlin: Lectura, Escritura y Constantes

Tipos de Variables y Operaciones en Kotlin

Tipos de Datos y Objetos en Kotlin: Ventajas y Funcionalidades

Operadores y Funciones en Kotlin: Uso y Extensión

Programación Funcional en Kotlin: Paradigmas y Variables Inmutables

Estructuras de Control: Uso de IF en Kotlin

Estructura de Control "When" en Kotlin: Uso y Ejemplos Prácticos

Conceptos básicos de Kotlin

Bucle while y do-while en Kotlin: Condicionales y Ejecución

Ciclo For y Funciones de Extensión en Kotlin

Null Safety en Kotlin: Evita Errores por Referencias Nulas

Gestión de Tipos Nulables en Kotlin y Buenas Prácticas

Manejo de Excepciones en Kotlin: Try-Catch y Lanzamiento de Errores

Uso del Operador Elvis en Kotlin para Nulables

Collections en Kotlin

Listas y Arrays en Kotlin: Tipos y Operaciones Básicas

Ordenar y Manipular Listas en Kotlin: Funciones Clave y Ejemplos

Uso de Maps en Kotlin: Clave-Valor y Tipos Mutable e Inmutable

Sets en Kotlin: Uso, Eliminación y Obtención de Elementos

Libera el potencial de las funciones

Creación de funciones propias en Kotlin

Creación de Funciones en Kotlin: Uppercase y Lowercase Aleatorios

Parámetros Nombrados y por Defecto en Funciones de Programación

Creación y Uso de Lambdas en Kotlin

Funciones de Alto Orden y Lambdas en Kotlin

Scope functions

Uso de la función let en Kotlin para variables nulas

Uso de la función "with" en Kotlin para manejar propiedades

Uso de la Función Run para Operaciones en Listas en Kotlin

Uso de la función apply para manejar tipos anulables en Kotlin

Uso de la Función Also en Kotlin para Encadenamiento de Operaciones

Proyecto: Bola 8 mágica

Creación de Menú Interactivo en Kotlin para Proyecto Bola Ocho

Funcionalidades avanzadas en Kotlin: Menús y manejo de respuestas

Desarrollo de Proyectos con Kotlin para Android y Backend

Funcionalidades avanzadas en Kotlin: Menús y manejo de respuestas