Operadores En Kotlin

ANUNCIO
Loading...

En este tutorial, aprenderás acerca de los operadores en Kotlin y cómo usarlos para crear expresiones con variables.

Operadores De Signo

Comenzamos con los operadores unarios que representan la propiedad de un número de ser negativo, representado por -, o positivo, representado por +.

OperadorExpresiónFunción equivalente
++aa.unaryPlus()
--aa.unaryMinus()

Ejemplo: Negar una variable con el valor de -3

fun main() { val a = -3 println("a=${-a}") }
Lenguaje del código: Kotlin (kotlin)

Por ley de signos la salida será:

a=3

Operadores Aritméticos

Te permiten expresar operaciones aritméticas entre dos operandos.

OperadorOperaciónExpresiónFunción Equivalente
+Sumaa+ba.plus(b)
-Restaa-ba.minus(b)
*Multiplicacióna*ba.times(b)
/Divisióna/ba.div(b)
%Residuoa%ba.rem(b)

Ejemplo: Imprimir el resultado de todas las operaciones aritméticas con los números 10 y 20.

fun main() { val a = 10 val b = 20 println("($a + $b)= ${a + b}") println("($a - $b)= ${a - b}") println("($a x $b)= ${a * b}") println("($a / $b)= ${a / b}") println("($a % $b)= ${a % b}") }
Lenguaje del código: Kotlin (kotlin)

El resultado sería:

(10 + 20)= 30 (10 - 20)= -10 (10 x 20)= 200 (10 / 20)= 0 (10 % 20)= 10

Como ves, al dividir dos enteros, se conserva la parte entera como resultado y se descartan lo decimales.

Operadores De Asignación Compuesta

Estos operadores son la combinación entre el operador de asignación y los operadores aritméticos, con el fin de usar como operando la variable de resultado.

Por ejemplo: si quieres acumular el valor de b en a, la abreviación para el operador compuesto de suma es la siguiente:

a += b // a = a + b
Lenguaje del código: JavaScript (javascript)

De esta manera, la siguiente tabla resume a los demás:

OperadorExpresión simplificadaExpresión CompletaFunción Equivalente
+=a+=ba=a+ba.plusAssign(b)
-=a-=ba=a-ba.minusAssign(b)
*=a*=ba=a*ba.timesAssign(b)
/=a/=ba=a/ba.divAssign(b)
%=a%=ba=a%ba.remAssign(b)

Ejemplo: Aplicar todos los operadores de asignación compuesta con un operando de 5 sobre un valor de 100. Al final imprimir el resultado.

fun main() { var a = 100 val b = 5 a += b println("+= $a") a -= b println("-= $a") a *= b println("*= $a") a /= b println("/= $a") a %= b println("%= $a") }
Lenguaje del código: Kotlin (kotlin)

La salida de la ejecución será:

+= 105 -= 100 *= 500 /= 100 %= 0

Operadores De Incremento Y Decremento

El operador de incremento, representado por dos signos de suma (++), incrementa en la unidad al operando.

monstersKilled++

Análogamente, el operador de decremento, doble signo menos (--), disminuye en la unidad al operando.

hearts--

El incremento depende de si el operador es prefijo o sufijo del operando:

  • Prefijo: Se realiza el incremento sobre la variable y luego es usada en la expresión que la contiene.
  • Sufijo: Se usa la variable en la expresión y luego si se aplica el incremento.

Ejemplo: Declarar una variable entera con el valor de 2 e imprimir su valor luego de incrementar con prefijo y decrementar con sufijo.

fun main() { var a = 2 println("De $a a ${++a}") println("De $a a ${a--}") println("Valor final > $a") }
Lenguaje del código: Kotlin (kotlin)

El resultado será:

De 2 a 3 De 3 a 3 Valor final > 2
Lenguaje del código: PHP (php)

Aunque el valor es disminuido en la segunda impresión, este no se hace efectivo sino hasta que se termina la línea. Por eso el resultado final es 2 en la tercera impresión.

Operadores Relacionales

Los operadores relacionales te permiten verificar enunciados de igualdad y desigualdad entre dos valores. El tipo de dato resultante de la expresión es Boolean, indicando la veracidad del enunciado expresado.

Aquí hay una la tabla de estos operadores:

OperadorEnunciadoExpresiónFunción Equivalente
==a es igual a ba==ba?.equals(b) ?: (b === null)
!=a es diferente de ba!=b!(a?.equals(b) ?: (b === null))
<a es menor que ba<ba.compareTo(b)<0
>a es mayor que ba>ba.compareTo(b)>0
<=a es menor ó igual que ba<=ba.compareTo(b)<=0
>=a es mayor o igual que ba>=ba.compareTo(b)>=0

Ejemplo: Usar los operadores relacionales entre los números 17 y 20.

fun main() { val a = 17 val b = 20 println("$a es igual a $b: ${a == b}") println("$a es diferente a $b: ${a != b}") println("$a es menor que $b: ${a < b}") println("$a es mayor que $b: ${a > b}") println("$a es menor o igual que $b: ${a <= b}") println("$a es mayor o igual que $b: ${a >= b}") }
Lenguaje del código: Kotlin (kotlin)

La salida será:

17 es igual a 20: false 17 es diferente a 20: true 17 es menor que 20: true 17 es mayor que 20: false 17 es menor o igual que 20: true 17 es mayor o igual que 20: false
Lenguaje del código: JavaScript (javascript)

Operadores Lógicos

Los operadores lógicos te permiten crear expresiones de lógica proposicional como lo son conjunción, disyunción y negación.

OperadorDescripciónExpresión
&&Conjunción (and): el resultado es true si a y b son truea&&b
||Disyunción (or): el resultado es true si a o b son truea||b
!Negación (not): el resultado es false si a es true, o viceversa!a

Ejemplo: Usar las proposiciones «5 mayor que 0» y «5 es par» para comprobar el funcionamiento de los operadores lógicos.

fun main() { val input = 5 var res: Boolean val greaterThanZero = input > 0 val isEven = input % 2 == 0 res = greaterThanZero && isEven println("Es mayor que cero y par:$res") res = greaterThanZero || isEven println("Es mayor que cero o par:$res") res = greaterThanZero && !isEven println("Es mayor que cero e impar:$res") }
Lenguaje del código: JavaScript (javascript)

Operadores A Nivel De Bits

Kotlin provee funciones para los tipos primitivos enteros, que actúan como operadores a nivel de bits.

FunciónDescripciónExpresión
and()and bit a bita and b
or()or bit a bita or b
xor()xor bit a bita xor b
inv()not bit a bita.inv()
shl()Desplazamiento de bits a la izquierdaa shl b
shr()Desplazamiento de bits a la derechaa shr b
ushr()Desplazamiento de bits a la derecha sin signoa ushr b

Ejemplo: Operar a nivel de bits los números enteros 5 y 7.

fun main() { val a = 5 val b = 7 println("a and b: ${a and b}") println("a or b: ${a or b}") println("a xor b: ${a xor b}") println("a.inv(): ${a.inv()}") println("a shl b: ${a shl b}") println("a shr b: ${a shr b}") println("a ushr b: ${a ushr b}") }
Lenguaje del código: Kotlin (kotlin)

El resultado de las operaciones a nivel de bits sería:

a and b: 5 a or b: 7 a xor b: 2 a.inv(): -6 a shl b: 640 a shr b: 0 a ushr b: 0
Lenguaje del código: CSS (css)

¿Qué Sigue?

Una vez discutido el uso de operadores en Kotlin el siguiente paso es aprender sobre la conversión de tipos en el lenguaje.

¿Ha sido útil esta publicación?

ANUNCIO
Loading...