Scala es un lenguaje de programación que combina programación orientada a objetos y funcional. Aquí tienes un resumen de la sintaxis básica y los tipos de datos más comunes en Scala:
En Scala, puedes declarar variables utilizando val para valores inmutables (constantes) y var para valores mutables:
// Declaración de variables
val edad: Int = 30 // Variable inmutable
var nombre: String = "Juan" // Variable mutable
// Comentarios
// Este es un comentario de una sola línea
/*
Este es un comentario
de varias líneas
*/
// Bloque de código
{
val x = 10
val y = 20
x + y
}
// Expresiones y Semicolons
val a = 10
val b = 20; val c = 30
// Tipos de datos básicos
val entero: Int = 10
val largo: Long = 1000000000L
val corto: Short = 32767
val byte: Byte = 127
val flotante: Float = 3.14f
val doble: Double = 3.141592653589793
val esCierto: Boolean = true
val esFalso: Boolean = false
val inicial: Char = 'A'
// Tipos de datos compuestos
val mensaje: String = "Hola, Scala!"
val numeros: Array[Int] = Array(1, 2, 3, 4, 5)
val frutas: List[String] = List("Manzana", "Plátano", "Naranja")
val persona: (String, Int) = ("Juan", 30)
Declaración de Variables:
val edad: Int = 30: Declara una variable inmutable edad de tipo Int con valor 30.var nombre: String = "Juan": Declara una variable mutable nombre de tipo String inicializada con "Juan".Comentarios:
//: Comentario de una sola línea./* ... */: Comentario de varias líneas.Bloque de Código:
{ ... }: Delimita un bloque de código que puede contener múltiples expresiones.Expresiones y Semicolons:
; al final de cada expresión, pero se puede usar para separar múltiples expresiones en la misma línea.Tipos de Datos Básicos:
Int, Long, Short, Byte: Tipos de datos enteros de diferentes tamaños.Float, Double: Tipos de datos de punto flotante de precisión simple y doble.Boolean: Tipo de dato booleano que puede ser true o false.Char: Tipo de dato para un solo carácter Unicode.Tipos de Datos Compuestos:
String: Tipo de dato para secuencias de caracteres.Array[Int]: Tipo de dato para un arreglo mutable de enteros.List[String]: Tipo de dato para una lista inmutable de cadenas.Tuple: Tipo de dato para agrupar elementos de diferentes tipos en una secuencia ordenada.Esta estructura y ejemplos te proporcionan una base sólida para comenzar a programar en Scala, combinando orientación a objetos y programación funcional con una sintaxis clara y expresiva.
En Scala, tanto las variables como las constantes son formas de almacenar y manipular datos. Sin embargo, tienen diferencias fundamentales en cuanto a su mutabilidad y asignación de valor. Entender estas diferencias es crucial para escribir código claro y eficiente.
var) y Constantes (val)Variables (var):
var.Constantes (val):
val.A continuación, se presenta un ejemplo que ilustra el uso de variables y constantes en Scala:
// Declaración de variables y constantes
val edad: Int = 30 // Constante inmutable
var nombre: String = "Juan" // Variable mutable
// Uso de variables y constantes
nombre = "Carlos" // Se puede cambiar el valor de una variable mutable (var)
// edad = 31 // Esto generaría un error, ya que 'edad' es una constante (val)
// Tipos de datos
val salario: Double = 2500.50 // Constante inmutable con tipo Double
var contador: Int = 0 // Variable mutable con tipo Int
// Inferencia de tipos
val pi = 3.1416 // Scala puede inferir el tipo de dato (Double en este caso)
var mensaje = "Hola, Mundo!" // Scala también puede inferir el tipo de String
// Impresión de variables
println(nombre) // Imprime: Carlos
println(salario) // Imprime: 2500.5
println(contador) // Imprime: 0
println(pi) // Imprime: 3.1416
println(mensaje) // Imprime: Hola, Mundo!
Declaración de Variables y Constantes:
val edad: Int = 30: Declara una constante (val) llamada edad de tipo Int con valor inicial 30. Una vez asignado, no se puede cambiar su valor.var nombre: String = "Juan": Declara una variable (var) llamada nombre de tipo String inicializada con "Juan". Puede cambiar su valor más adelante con una nueva asignación.Uso de Variables y Constantes:
nombre = "Carlos": Cambia el valor de la variable mutable nombre de "Juan" a "Carlos".edad (ejemplo: edad = 31) generaría un error porque edad es una constante (val).Tipos de Datos:
salario: Double = 2500.50: Declara una constante (val) salario de tipo Double.contador: Int = 0: Declara una variable (var) contador de tipo Int.Inferencia de Tipos:
val pi = 3.1416: Scala puede inferir el tipo de dato automáticamente basándose en el valor asignado (Double en este caso).var mensaje = "Hola, Mundo!": Scala también puede inferir el tipo de dato String.Impresión de Variables:
println(nombre): Imprime el valor actual de nombre, que es "Carlos".println(salario): Imprime el valor de salario, que es 2500.5.println(contador): Imprime el valor de contador, que es 0.println(pi): Imprime el valor de pi, que es 3.1416.println(mensaje): Imprime el valor de mensaje, que es "Hola, Mundo!".Los operadores y expresiones son fundamentales en cualquier lenguaje de programación para realizar cálculos y manipulaciones de datos. En Scala, tenemos una variedad de operadores aritméticos, relacionales, lógicos y otros, que nos permiten realizar diversas operaciones. Aquí te explico los principales tipos de operadores y cómo usarlos en Scala:
// Operadores y expresiones en Scala
// Operadores aritméticos
val suma = 10 + 5 // Suma: 15
val resta = 10 - 5 // Resta: 5
val multiplicacion = 10 * 5 // Multiplicación: 50
val division = 10 / 5 // División: 2
val modulo = 10 % 3 // Módulo: 1
val negativo = -suma // Negativo: -15
// Operadores relacionales
val igual = 10 == 10 // Igual a: true
val distinto = 10 != 5 // Distinto de: true
val mayor = 10 > 5 // Mayor que: true
val menor = 10 < 5 // Menor que: false
val mayorIgual = 10 >= 10 // Mayor o igual que: true
val menorIgual = 10 <= 5 // Menor o igual que: false
// Operadores lógicos
val and = (10 > 5) && (5 < 10) // AND lógico: true
val or = (10 > 5) || (5 > 10) // OR lógico: true
val not = !(10 > 5) // NOT lógico: false
// Operadores de asignación
var a = 10
a += 5 // Equivalente a: a = a + 5
var b = 20
b *= 2 // Equivalente a: b = b * 2
// Expresiones
val x = 10
val y = 5
val resultado = (x + y) * (x - y) // Resultado: 75
// Orden de evaluación
val resultado2 = 10 + 5 * 2 // Resultado: 20 (multiplicación primero)
val resultado3 = (10 + 5) * 2 // Resultado: 30 (suma primero)
// Impresión de resultados
println(s"Operadores aritméticos:")
println(s"Suma: $suma")
println(s"Resta: $resta")
println(s"Multiplicación: $multiplicacion")
println(s"División: $division")
println(s"Módulo: $modulo")
println(s"Negativo: $negativo")
println("\nOperadores relacionales:")
println(s"Igual a: $igual")
println(s"Distinto de: $distinto")
println(s"Mayor que: $mayor")
println(s"Menor que: $menor")
println(s"Mayor o igual que: $mayorIgual")
println(s"Menor o igual que: $menorIgual")
println("\nOperadores lógicos:")
println(s"AND lógico: $and")
println(s"OR lógico: $or")
println(s"NOT lógico: $not")
println("\nOperadores de asignación:")
println(s"Valor de a después de a += 5: $a")
println(s"Valor de b después de b *= 2: $b")
println("\nExpresiones:")
println(s"Resultado de la expresión (x + y) * (x - y): $resultado")
println("\nOrden de evaluación:")
println(s"Resultado de 10 + 5 * 2: $resultado2")
println(s"Resultado de (10 + 5) * 2: $resultado3")
Operadores Aritméticos: Realizan operaciones matemáticas básicas como suma (+), resta (-), multiplicación (*), división (/), módulo (%), y negación (-).
Operadores Relacionales: Comparan valores y devuelven un resultado booleano (true o false). Incluyen igualdad (==), desigualdad (!=), mayor que (>), menor que (<), mayor o igual que (>=), y menor o igual que (<=).
Operadores Lógicos: Permiten combinar expresiones booleanas. Los operadores son && (AND lógico), || (OR lógico), y ! (NOT lógico).
Operadores de Asignación: Permiten asignar y operar valores en una misma expresión. Ejemplos incluyen += y *=.
Expresiones: Combinan valores, variables y operadores para producir un resultado. Por ejemplo, (x + y) * (x - y) calcula el resultado basado en los valores de x y y.
Orden de Evaluación: Scala sigue reglas estándar de precedencia de operadores. Los paréntesis se pueden usar para controlar el orden de evaluación.
Impresión de Resultados: Utilizamos println para mostrar los resultados de cada operación y expresión en la consola.
El control de flujo en Scala permite gestionar cómo se ejecutan las instrucciones de un programa según ciertas condiciones o repeticiones. Utilizamos estructuras condicionales como if-else para tomar decisiones basadas en condiciones booleanas y bucles como for y while para repetir bloques de código.
// Condicionales y bucles en Scala
// Ejemplo de condicional if-else
val edad = 25
if (edad >= 18) {
println("Eres mayor de edad")
} else {
println("Eres menor de edad")
}
// Ejemplo de condicional con expresión
val calificacion = 75
val resultado = if (calificacion >= 60) "Aprobado" else "Reprobado"
println(s"Resultado de la calificación: $resultado")
// Ejemplo de bucle for
println("\nBucle for:")
for (i <- 1 to 5) {
println(s"Iteración $i")
}
// Ejemplo de bucle while
println("\nBucle while:")
var contador = 0
while (contador < 5) {
println(s"Contador: $contador")
contador += 1
}
Condicionales (if-else):
edad >= 18 en el primer ejemplo). Si la condición es verdadera, se ejecuta el bloque dentro de {}, de lo contrario, se ejecuta el bloque dentro de {}.Condicionales con Expresión:
if-else puede ser utilizado como una expresión que devuelve un valor ("Aprobado" o "Reprobado" en el segundo ejemplo) basado en la evaluación de la condición (calificacion >= 60).Bucle for:
1 to 5 en el ejemplo). En cada iteración, la variable i toma el valor del elemento actual de la secuencia y se ejecuta el bloque de código dentro de {}.Bucle while:
contador < 5 en el ejemplo). Cada vez que se completa una iteración del bucle, la variable contador se incrementa en 1 hasta que la condición ya no se cumple.