0Pricing
Scala for Backend Engineering & Functional Programming · Lección

Sintaxis y tipos básicos

Comprenda la sintaxis fundamental de Scala, las declaraciones de variables (val/var), los tipos de datos habituales y los operadores básicos.

Sintaxis y tipos básicos es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 3 lecciones en total.

La sintaxis limpia de Scala

¡Le damos la bienvenida a la sintaxis básica de Scala! Scala está diseñado para ser conciso y expresivo, lo que a menudo permite escribir menos código para lograr más.

A diferencia de algunos lenguajes, normalmente los puntos y coma son opcionales al final de una línea si solo contiene una instrucción. Esto ayuda a mantener el código limpio.

Las expresiones son fundamentales

En Scala, casi todo es una expresión, lo que significa que se evalúa y produce un valor. Este es un concepto potente que hace que el código sea más funcional y predecible.

Incluso un cálculo sencillo o un bloque condicional puede devolver un valor.

Pruebe a ejecutar este ejemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val x = 5 + 3
    println(s"The value of x is: $x")

    val message = if (x > 7) "Greater than 7" else "Not greater than 7"
    println(message)
  }
}

`val`: valores inmutables

Cuando declara una variable mediante val, está creando un valor inmutable. Esto significa que, una vez asignado, su valor no puede cambiarse.

La inmutabilidad es un pilar de la programación funcional y ayuda a evitar efectos secundarios inesperados, lo que hace que el código sea más seguro y fácil de razonar.

Pruébelo:

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "Hello, Coddy!"
    println(greeting)
    // greeting = "New message" // This would cause a compile error!
  }
}

`var`: variables mutables

A veces necesita una variable cuyo valor pueda cambiar. Para ello, Scala proporciona var para las variables mutables.

Aunque resulta útil, en Scala es recomendable preferir val a var siempre que sea posible, para adoptar la inmutabilidad y el estilo funcional.

Vea cómo funciona `var`:

object Main {
  def main(args: Array[String]): Unit = {
    var counter = 0
    println(s"Initial counter: $counter")
    counter = counter + 1
    println(s"New counter: $counter")
  }
}

Números: Int, Long, Double

Scala admite tipos numéricos comunes. A menudo, el compilador infiere el tipo, pero también puede especificarlo.

  • Int: para números enteros (por ejemplo, 10)
  • Long: para números enteros grandes (sufijo L, por ejemplo, 10000000000L)
  • Double: para números de coma flotante (decimales, por ejemplo, 3.14)

Este es un ejemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val anInt = 42
    val aLong = 1234567890123L
    val aDouble = 3.14159

    println(s"Int: $anInt")
    println(s"Long: $aLong")
    println(s"Double: $aDouble")
  }
}

Tipos Boolean y Char

Además de los números, Scala cuenta con tipos para valores booleanos y caracteres individuales:

  • Boolean: representa valores booleanos, ya sea true o false.
  • Char: almacena un solo carácter, entre comillas simples (por ejemplo, 'A').

Son fundamentales para la lógica y el procesamiento de texto.

Ejemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val isActive = true
    val initial = 'C'

    println(s"Is active? $isActive")
    println(s"Initial character: $initial")
  }
}

Cadenas y texto

El tipo String se utiliza para secuencias de caracteres o texto. Las cadenas son inmutables en Scala, al igual que en Java.

Una función muy útil es la interpolación de cadenas, que permite insertar expresiones directamente en literales de cadena mediante un prefijo s y $ para las variables.

Vea este ejemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Coddy"
    val age = 3

    val greeting = s"Hello, my name is $name and I am $age years old."
    println(greeting)

    val mathResult = s"Two plus two is ${2 + 2}"
    println(mathResult)
  }
}

Operadores aritméticos básicos

Scala proporciona operadores aritméticos estándar para realizar cálculos con números:

  • + (suma)
  • - (resta)
  • * (multiplicación)
  • / (división)
  • % (módulo: resto de la división)

Estos operadores funcionan como espera y devuelven un nuevo valor numérico.

Hagamos algunas operaciones:

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

    println(s"Addition: ${a + b}")
    println(s"Subtraction: ${a - b}")
    println(s"Multiplication: ${a * b}")
    println(s"Division: ${a / b} (integer division)")
    println(s"Modulo: ${a % b}")

    val c = 10.0
    val d = 3.0
    println(s"Float Division: ${c / d}")
  }
}

Operadores de comparación

Los operadores de comparación se utilizan para comparar dos valores y siempre devuelven un Boolean (true o false).

  • == (igual a)
  • != (distinto de)
  • < (menor que)
  • > (mayor que)
  • <= (menor o igual que)
  • >= (mayor o igual que)

Son esenciales para el flujo de control y la toma de decisiones.

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

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

Comprobación rápida: variables y operadores

Considere el siguiente fragmento de código de Scala:

object Main {
  def main(args: Array[String]): Unit = {
    val num1 = 7
    var num2 = 3
    num2 = num1 * 2
    val finalResult = num1 + num2 - 5
    println(finalResult)
  }
}

Repaso: sintaxis y tipos

¡Buen trabajo! En esta lección ha aprendido los fundamentos de la sintaxis básica de Scala, incluido el uso de expresiones y el carácter opcional de los puntos y coma.

Hemos visto cómo declarar variables usando val para valores inmutables y var para valores mutables. También se ha familiarizado con tipos de datos comunes como Int, Long, Double, Boolean, Char y String, incluida la útil interpolación de cadenas.

Por último, ha practicado el uso de operadores aritméticos y de comparación básicos para realizar cálculos y comprobaciones lógicas. Siga practicando estos conceptos básicos, ya que son los bloques de construcción de programas de Scala más complejos.

Preguntas frecuentes

¿La lección «Sintaxis y tipos básicos» es gratis?

Sí — el texto completo de «Sintaxis y tipos básicos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 3 lecciones en total.

¿Qué aprenderé en «Sintaxis y tipos básicos»?

Comprenda la sintaxis fundamental de Scala, las declaraciones de variables (val/var), los tipos de datos habituales y los operadores básicos. Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Sintaxis y tipos básicos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Primeros pasos con Scala
  2. Sintaxis y tipos básicos
  3. Estructuras de control y funciones
← Volver a Scala for Backend Engineering & Functional Programming