Los operadores lógicos en Kotlin te permiten tomar decisiones dentro de tu programa evaluando expresiones que devuelven true o false. Son la base para validar datos, controlar flujos y construir lógica de negocio en cualquier aplicación.

Aquí vas a entender cómo funcionan los operadores de comparación, los conectores lógicos and, or y not, y cómo combinarlos para resolver casos reales como validar un email o detectar contraseñas problemáticas.

¿Qué son los operadores lógicos y para qué sirven?

Los operadores lógicos evalúan condiciones y devuelven un resultado booleano: verdadero o falso. Con ese resultado tu programa decide qué camino tomar [0:08].

En Kotlin, los más comunes se agrupan en tres familias:

• Operadores de comparación: >, <, >=, <=, ==, !=.
• Operadores lógicos: && (and), || (or), ! (not).
• Funciones booleanas de tipos como String: contains(), length.

¿Qué devuelve un operador lógico en Kotlin? Devuelve un valor de tipo Boolean, es decir, true o false, que puedes guardar en una variable o usar dentro de un if.

¿Cómo comparo valores con mayor que, menor que e igual?

Imagina que tienes tres variables iniciales para una bandeja de entrada [1:05]:

kotlin val emailsRecibidos = 15 val emailsEnviados = 10 val limiteEmails = 20

Con estas, puedes construir comparaciones que se almacenan en variables booleanas.

¿Cómo verifico si tengo emails con el operador mayor que?

El operador > evalúa si un número supera a otro [1:33]:

kotlin val tieneEmails = emailsRecibidos > 0 println("Tiene emails: $tieneEmails")

Como 15 es mayor que 0, el resultado es true. Si cambias la comparación a 15 > 16, obtendrás false.

¿Cómo uso mayor o igual y comparación de igualdad?

El operador >= te ayuda a saber si alcanzaste un límite [2:42]:

kotlin val excedeEnviados = emailsEnviados >= limiteEmails

Si emailsEnviados es 20 y limiteEmails es 20, el resultado es true porque 20 sí es mayor o igual a 20.

Para comparar igualdad usa ==, y para diferencia usa != [3:55]:

kotlin val sonIguales = emailsRecibidos == emailsEnviados val sonDiferentes = emailsRecibidos != emailsEnviados

¿Cuál es la diferencia entre = y == en Kotlin? Un solo = asigna un valor a una variable. Dos == comparan dos valores y devuelven true o false.

¿Cómo combino condiciones con and, or y not?

Los operadores lógicos te permiten unir varias expresiones para tomar decisiones más complejas. Aquí entran en juego validaciones reales, como verificar un email o una contraseña.

¿Cómo valido un email con el operador and?

Los Strings en Kotlin tienen funciones como contains() que devuelven booleanos [5:55]:

kotlin val email = "correo@example.com" val tieneArroba = email.contains("@") val tienePunto = email.contains(".") val esEmailValido = tieneArroba && tienePunto

El operador && (and) solo devuelve true cuando ambas condiciones se cumplen al mismo tiempo [7:05]. Si una falla, el resultado completo es false.

¿Cómo detecto una contraseña problemática con or?

El operador || (or) devuelve true cuando al menos una de las condiciones se cumple [8:25]:

kotlin val password = "1234" val passwordCorto = password.length < 6 val passwordLargo = password.length > 20 val passwordProblematico = passwordCorto || passwordLargo

Una contraseña con 4 caracteres entra como problemática porque cumple passwordCorto. Una de más de 20 caracteres también lo hace. Solo si ambas son falsas, el resultado final es false.

¿Para qué sirve el operador de negación not?

El operador ! invierte un valor booleano: convierte true en false y viceversa [10:08]:

kotlin val esEmailInvalido = !esEmailValido

Si tu email es válido, al aplicar la negación obtienes false para esEmailInvalido. Es útil cuando quieres expresar lo contrario de una condición que ya construiste.

¿Cómo aplico todo esto en una validación real de spam?

Un caso práctico: aceptar un email en tu bandeja solo si cumple varias reglas a la vez [11:24].

Las reglas son:

• El email debe contener @ y ..
• El email no debe contener la palabra test en el dominio.
• El asunto no debe contener gratis ni urgente.

kotlin val email = "hola@dominio.com" val asunto = "Reunión del lunes"

val esEmailValido = email.contains("@") && email.contains(".") && !email.contains("test") val noEsSpam = !asunto.contains("gratis") && !asunto.contains("urgente") val esAceptable = esEmailValido && noEsSpam

Fíjate cómo los && encadenan validaciones positivas y los ! excluyen palabras no deseadas. Al combinar ambos bloques con un and, obtienes una decisión final clara: el correo entra o se descarta.

Practica creando tus propias combinaciones cambiando los valores de email y asunto, y comparte en los comentarios qué validación adicional agregarías a tu bandeja.