El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Operaciones Básicas y Expresiones

Siguiente ►
►

En esta sección, aprenderemos sobre las operaciones básicas y las expresiones en Scala. Este conocimiento es fundamental para realizar cálculos, manipular datos y construir lógica en tus programas.

  1. Operadores Aritméticos

Scala soporta los operadores aritméticos básicos que se utilizan para realizar operaciones matemáticas. Aquí están los operadores más comunes:

Operador Descripción Ejemplo Resultado
+ Suma 5 + 3 8
- Resta 5 - 3 2
* Multiplicación 5 * 3 15
/ División 6 / 3 2
% Módulo (residuo) 5 % 3 2

Ejemplo Práctico

object ArithmeticOperations {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 3

    println(s"Suma: $a + $b = ${a + b}")
    println(s"Resta: $a - $b = ${a - b}")
    println(s"Multiplicación: $a * $b = ${a * b}")
    println(s"División: $a / $b = ${a / b}")
    println(s"Módulo: $a % $b = ${a % b}")
  }
}

Explicación del Código

  • val a = 10 y val b = 3: Declaramos dos variables a y b con valores 10 y 3 respectivamente.
  • println(s"Suma: $a + $b = ${a + b}"): Utilizamos la interpolación de cadenas para imprimir el resultado de la suma de a y b.
  • Las demás líneas siguen el mismo patrón para las operaciones de resta, multiplicación, división y módulo.

  1. Operadores Relacionales

Los operadores relacionales se utilizan para comparar dos valores. El resultado de una operación relacional es un valor booleano (true o false).

Operador Descripción Ejemplo Resultado
== Igual a 5 == 3 false
!= No igual a 5 != 3 true
> Mayor que 5 > 3 true
< Menor que 5 < 3 false
>= Mayor o igual que 5 >= 3 true
<= Menor o igual que 5 <= 3 false

Ejemplo Práctico

object RelationalOperators {
  def main(args: Array[String]): Unit = {
    val x = 5
    val y = 3

    println(s"$x == $y: ${x == y}")
    println(s"$x != $y: ${x != y}")
    println(s"$x > $y: ${x > y}")
    println(s"$x < $y: ${x < y}")
    println(s"$x >= $y: ${x >= y}")
    println(s"$x <= $y: ${x <= y}")
  }
}

Explicación del Código

  • val x = 5 y val y = 3: Declaramos dos variables x y y con valores 5 y 3 respectivamente.
  • println(s"$x == $y: ${x == y}"): Utilizamos la interpolación de cadenas para imprimir el resultado de la comparación x == y.
  • Las demás líneas siguen el mismo patrón para las otras operaciones relacionales.

  1. Operadores Lógicos

Los operadores lógicos se utilizan para combinar múltiples expresiones booleanas.

Operador Descripción Ejemplo Resultado
&& AND lógico (5 > 3) && (3 > 1) true
` ` OR lógico
! NOT lógico !(5 > 3) false

Ejemplo Práctico

object LogicalOperators {
  def main(args: Array[String]): Unit = {
    val a = true
    val b = false

    println(s"a && b: ${a && b}")
    println(s"a || b: ${a || b}")
    println(s"!a: ${!a}")
  }
}

Explicación del Código

  • val a = true y val b = false: Declaramos dos variables booleanas a y b.
  • println(s"a && b: ${a && b}"): Utilizamos la interpolación de cadenas para imprimir el resultado de la operación lógica a && b.
  • Las demás líneas siguen el mismo patrón para las otras operaciones lógicas.

  1. Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a las variables.

Operador Descripción Ejemplo Resultado
= Asignación simple x = 5 x = 5
+= Asignación con suma x += 3 x = x + 3
-= Asignación con resta x -= 3 x = x - 3
*= Asignación con multiplicación x *= 3 x = x * 3
/= Asignación con división x /= 3 x = x / 3
%= Asignación con módulo x %= 3 x = x % 3

Ejemplo Práctico

object AssignmentOperators {
  def main(args: Array[String]): Unit = {
    var x = 5

    println(s"x = $x")
    x += 3
    println(s"x += 3: $x")
    x -= 2
    println(s"x -= 2: $x")
    x *= 2
    println(s"x *= 2: $x")
    x /= 3
    println(s"x /= 3: $x")
    x %= 2
    println(s"x %= 2: $x")
  }
}

Explicación del Código

  • var x = 5: Declaramos una variable x con valor 5.
  • x += 3: Incrementamos el valor de x en 3.
  • Las demás líneas siguen el mismo patrón para las otras operaciones de asignación.

Ejercicios Prácticos

Ejercicio 1

Escribe un programa que tome dos números enteros como entrada y realice las siguientes operaciones: suma, resta, multiplicación, división y módulo. Imprime los resultados.

Solución

object BasicOperationsExercise {
  def main(args: Array[String]): Unit = {
    val num1 = 12
    val num2 = 4

    println(s"Suma: $num1 + $num2 = ${num1 + num2}")
    println(s"Resta: $num1 - $num2 = ${num1 - num2}")
    println(s"Multiplicación: $num1 * $num2 = ${num1 * num2}")
    println(s"División: $num1 / $num2 = ${num1 / num2}")
    println(s"Módulo: $num1 % $num2 = ${num1 % num2}")
  }
}

Ejercicio 2

Escribe un programa que tome dos valores booleanos y realice las siguientes operaciones lógicas: AND, OR y NOT. Imprime los resultados.

Solución

object LogicalOperationsExercise {
  def main(args: Array[String]): Unit = {
    val bool1 = true
    val bool2 = false

    println(s"bool1 && bool2: ${bool1 && bool2}")
    println(s"bool1 || bool2: ${bool1 || bool2}")
    println(s"!bool1: ${!bool1}")
  }
}

Conclusión

En esta sección, hemos cubierto las operaciones básicas y las expresiones en Scala, incluyendo operadores aritméticos, relacionales, lógicos y de asignación. Estos conceptos son fundamentales para cualquier tipo de programación y te preparan para avanzar a temas más complejos. Asegúrate de practicar los ejercicios para reforzar tu comprensión antes de pasar al siguiente módulo.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados