No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Estructuras de control: if

13/37
Recursos

¿Cómo funcionan las estructuras de control IF en Kotlin?

En el apasionante mundo de la programación, las estructuras de control son esenciales para dirigir el flujo del código basándonos en condiciones específicas. En Kotlin, el famoso lenguage de programación, el uso de la estructura if es fundamental para determinar qué bloques de código se ejecutan. Vamos a desglosar cómo podemos utilizar las estructuras if para robustecer tu código.

¿Cómo determinar si una variable está vacía?

Muchas veces necesitamos evaluar si ciertos valores existen o no antes de proceder con operaciones más complejas. Comencemos creando una variable:

var nombre = "María"

Utilizando la función isNotEmpty, podemos verificar si este nombre no está vacío y, basado en esa condición, ejecutar diferentes líneas de código:

if (nombre.isNotEmpty()) {
    println("El largo de nuestra variable nombre es ${nombre.length}")
} else {
    println("Error, la variable está vacía")
}

Aquí, al ver que el nombre "María" no está vacío, se imprimiría: "El largo de nuestra variable nombre es 5".

¿Cómo simplificar un IF?

Kotlin nos permite hacer más legibles nuestros if cuando se trata de una sola línea de código. Eliminando las llaves, se puede implementar la misma lógica:

if (nombre.isNotEmpty()) println("El largo de nuestra variable nombre es ${nombre.length}")
else println("Error, la variable está vacía")

El resultado sigue siendo el mismo, pero visualmente más limpio.

¿Cómo asignar un valor a una variable usando IF?

Supongamos que queremos asignar un mensaje dependiendo del largo del nombre:

val mensaje = if (nombre.length > 4) "Tu nombre es largo" else "Tienes un nombre corto"
println(mensaje)

Aquí, evaluamos el tamaño del nombre y asignamos un mensaje adecuado a la variable mensaje.

¿Cómo usar ELSEIF para múltiples condiciones?

A veces necesitamos más de una condición para cubrir todos los escenarios posibles. Ahí entra en juego elseif:

if (nombre.isEmpty()) {
    println("El nombre está vacío")
} else if (nombre.length > 4) {
    println("Tu nombre es largo")
} else {
    println("Tienes un nombre corto")
}

Con esta estructura, podemos comprobar si el nombre está vacío, es largo o corto, obteniendo así una respuesta más precisa.

¿Por qué es importante la inmutabilidad en Kotlin?

¡Gran pregunta! Kotlin promueve el uso de variables inmutables (usando val) siempre que sea posible, para mejorar la legibilidad y robustez de nuestro código. En el contexto de if, si solo asignamos un valor una vez a una variable después de una evaluación, es ideal declararla como val.

val mensaje = if (nombre.isEmpty()) {
    "El nombre está vacío"
} else if (nombre.length > 4) {
    "Tu nombre es largo"
} else {
    "Tienes un nombre corto"
}

println(mensaje)

Utilizar val asegura que mensaje no podrá cambiarse accidentalmente a lo largo de tu código. 

Conclusiones importantes

El uso efectivo de las estructuras de control if, else, y elseif puede definir claramente el flujo de tu programa y garantizar que se manejan adecuadamente todos los casos posibles. Al aplicar buenas prácticas como la inmutabilidad, no solo protegerás tu código de posibles errores, sino que también mejorarás su eficiencia y legibilidad. ¡Continúa evolucionando tus habilidades de programación y disfruta del camino de aprendizaje que has emprendido en Kotlin!

Aportes 24

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Para las personas que vengan de Java, los operadores ternarios tales como se conocen en java no existen en Kotlin, sin embargo, se puede utilizar un if de una sóla línea, por ejemplo:

//Java approach

String nombre = "Joe";
String message = nombre.equals("Joe") ? "Hello " + nombre : "I don't Know you";

//Kotlin approach
var nombre = "Joe"
var message = if(nombre.equals("Joe")) "Hello $nombre" else "I don't Know you"

Hay quienes dicen que no es un buen curso que no se que, que android que esto otro, recuerden, este NO es un curso de android con kotlin, como bien dice el titulo, es un curso de kotlin desde cero

Es mi imaginación o la sintaxis de Kotlin se asemeja mucho a la de Python, VBA y R





CONDICIONAL IF

Es un mecanismo que nos proporciona el lenguaje para evaluar condiciones que son true o false y así decidir que bloque de codigo se va a ejecutar.  

Para evaluar las condiciones con la sentencia if debemos aprender el concepto de operador condicional, este operador nos van a servir para evaluar condiciones, los operadores condicional son:  

> mayor que.
< menor que.
>= mayor o igual que.
<= menor o igual que
== igualdad.
!= desigualdad.  

OPERADORES LOGICOS

Con los operadores logicos podremos comparar mas de una condición.  

&& operador "y": con este operador todas las condiciones tienen que ser verdaderas para que se cumpla la sentencia if.  

|| operador "o": basta que se cumpla una de las condiciones para que se cumpla la sentencia if.  

! operador "no"

Les comparto el código con algunos comentarios

fun main(args: Array<String>) {
    val nombre = "Gera"  //Declaramos una variable y le asignamos un valor
    //Aqui empieza nuestra estructura de control IF
    //Tenemos una prueba logica (donde preguntamos si nombre no esta vacia)
    //Si esto es verdad [IF] entonces vamos a imprimer la cantidad de caracteres que hay en la variable nombre
    //Si esto no es verdad [else] vamos a imprimir un mensaje de error diciendo que la variable esta vacia
    if (nombre.isNotEmpty()) {
        println("El largo de nuestra variable nombre es ${nombre.length}")
    } else {
        println("Error, la variable se encuentra vacia")
    }
}

Con esta Imagen Podrían tener Una Idea mas clara de Que hace un IF.

Vengo del curso de JAVA con anahí. Cada vez que escribo algo en Kotlin le pongo el " ; " jajajaja ya es la costumbre xD

ecxelente curso, sencillo y con buenos fundamentos

Operador if: Es uno de nuestros operadores lógicos, esta sentencia va a funcionar a partir de la comparación de unos datos. El resultado será un valor booleano, true o false.

`fun ``main(args: Array<String>) {` ` ``val ``nombre : String = "ene"` ` ``println``(nombre)` ` ``// Comprobación de if` ` if ``(nombre.``isNotEmpty``()) ``println``("El largo de nuestra variable nombre es ${nombre.length}")` ` ``else println``("Error, nuestra variable esta vacia")` ` ``// Asignación de if` ` var ``mensaje : String` ` ``if ``(nombre.length > 8){` ` mensaje = "Tienes un nombre largo!"` ` } ``else ``{` ` mensaje = "Tienes un nombre corto"` ` }` ` ``println``(mensaje)` ` ``/*// Asignación de if inmutable` ` val mensajeInmutable = if (nombre.length > 8) "Tienes un nombre largo!" else "Tienes un nombre corto"` ` println(mensajeInmutable)` ` // Asignación de variable inmutable con else if` ` val mensajeInmutable2= if (nombre.length > 8) "Tienes un nombre largo!" else if(nombre.isEmpty()) "Este nombre esta vacio :(" else "Tienes un nombre corto"` ` println(mensajeInmutable2)*/` `}`
Hola compañeros, tengo una pequeña duda, en la sección donde utiliza if y imprime la variable mensaje fuera de los if, ¿no se supondría que no tendría que salir nada? o a que se debe eso.
```js fun main() { val nombre ="Maria" if(nombre.isNotEmpty()) println("El largo de nuestro nombre es ${nombre.length}") else println("Error la variable esta vacia") val mensaje : String when { nombre.length > 4 -> mensaje = "Tu nombre es largo" else -> mensaje = "tienes un nombre corto" } println(mensaje) } ```fun main() { val nombre ="Maria" if(nombre.*isNotEmpty*()) *println*("El largo de nuestro nombre es ${nombre.length}") else *println*("Error la variable esta vacia") val mensaje : String when { nombre.length > 4 -> mensaje = "Tu nombre es largo" else -> mensaje = "tienes un nombre corto" } *println*(mensaje) }

Horrible el curso, el pibe no tiene la suficiente experiencia como para enseñar

Este curso es un Wikipedia con Audio y Video y ya. Que triste/
interesante

basicamente if, else if y else son practicamente lo mismo que en otros lenguajes como JS

Gracias por el curso esta buenisimoooooo

Muy interesante la forma en que se ouede optimizar la asignacion de variables a partir de la evaluacion de las condiciones del if en Kotlin, ahi se ve aplicado claramente el objetivo de Kotlin de mantener mutable las operaciones

El asignar un valor después de haber evaluado una condicional es muy útil, yo vengo de Java y siempre se me hacia engorroso el tener que asignar el valor de la variable dentro de las condiciones y así queda mucho mas limpio y entendible. La primera vez que lo vi me voló la cabeza y esos detalles es la razón por la cual yo veo a Kotlin como Java con esteroides.

val votar = if(edad >= 18){
	true
}
else{
	false
}

Incluso se puede hacer mucho más corta de la siguiente manera:

val votar = if(edad >= 18) true else false

fun main(args: Array<String>) {
val nombre = “amb”

Mi codigo de esta clase!

if(nombre.isNotEmpty()) println(“El largo de nuestra variable nombre es ${nombre.length}”)
else println(“Error, la variable esta vacia”)
val mensaje : String = if (nombre.length > 4) {
“Tu nombre es largo”
} else if (nombre.isEmpty()) {
“El nombre esta vacio”
} else {
“Tienes un nombre corto”
}
println(mensaje)
}

val dato = "Maria"

    if(dato.isNotEmpty()){
        println("El largo del dato ${dato} es ${dato.length}")
    }else{
        println("Error, la variables esta vacia")
    }

La estructura de control If sera una de las herramientas mas utilziadas en cualquier lenguaje de programacion

fun main(args: Array<String>) {
val nombre = "Maria"

// validar si el nombre esta vacio
if(nombre.isNotEmpty()) println("El largo de nuestra variable nombre es ${nombre.length}") else println("Error, la variable esta vacia")

// El ejemplo anterior pero asignado el if a una variable, con una aginación inmutable
val mensaje = if(nombre.length > 4){
	"Tu nombre es largo" 
} else if (nombre.isEmpty()){
	"Nombre esta vacia"
} else {
	"Tienes un nombre corto"
}

}