Variables y Tipos

## Objetivos de Aprendizaje - Comprender las declaraciones val vs var - Dominar el sistema de tipos de Scala - Aprender inferencia de tipos - Trabajar con lazy val - Comprender tipos de datos basicos ## Declaraciones de Variables ### val (Inmutable) ```scala val x: Int = 10 val name: String = "Scala" val pi: Double = 3.14159 ``` Una vez asignada, una `val` no puede ser reasignada: ```scala val x = 10 x = 20 // Error: reasignacion a val ``` ### var (Mutable) ```scala var counter = 0 counter = counter + 1 // OK - var puede ser reasignado ``` ### Cuando usar val vs var Prefiere `val` por defecto para inmutabilidad. Usa `var` solo cuando la mutacion es necesaria. ## Sistema de Tipos ### Tipos Basicos | Tipo | Descripcion | Ejemplo | |------|-------------|---------| | Byte | Entero de 8 bits con signo | `val b: Byte = 127` | | Short | Entero de 16 bits con signo | `val s: Short = 32767` | | Int | Entero de 32 bits con signo | `val i: Int = 2147483647` | | Long | Entero de 64 bits con signo | `val l: Long = 9223372036854775807L` | | Float | Punto flotante de 32 bits | `val f: Float = 3.14f` | | Double | Punto flotante de 64 bits | `val d: Double = 3.14159` | | Char | Caracter Unicode de 16 bits | `val c: Char = 'A'` | | Boolean | verdadero o falso | `val flag: Boolean = true` | | String | Secuencia de caracteres | `val s: String = "Hello"` | ### Operaciones con Cadenas ```scala val str = "Hello, Scala" // Concatenacion val greeting = "Hello" + " " + "World" // Metodos de cadena str.length // 12 str.toUpperCase // HELLO, SCALA str.toLowerCase // hello, scala str.substring(0, 5) // Hello str.contains("Scala") // true // Interpolacion de cadenas val name = "Alice" val age = 30 println(s"Name: $name, Age: $age") println(s"Next year: ${age + 1}") // Cadena cruda val path = raw"C:\Users\test" ``` ### Cadenas Multilinea ```scala val poem = """ |Roses are red |Violets are blue |Scala is awesome |And so are you """.stripMargin ``` ## Inferencia de Tipos El compilador de Scala puede inferir tipos: ```scala val x = 10 // Se infiere como Int val name = "Scala" // Se infiere como String val pi = 3.14159 // Se infiere como Double val flag = true // Se infiere como Boolean // Explicito vs inferido val x: Int = 10 // Explicito val y = 20 // Se infiere como Int ``` ### Cuando Usar Tipos Explicitos - Declaraciones de API publicas (metodos, campos de clase) - El tipo no es inmediatamente obvio - Requerido para la compilacion en algunos casos ambiguos ## Jerarquia de Tipos ```text Any ├── AnyVal (tipos valor) │ ├── Int, Long, Double, Float, Boolean, Char, Unit │ └── Byte, Short └── AnyRef (tipos referencia) ├── String ├── List, Set, Map ├── Option, Try, Either └── Todas las clases Java/Scala ``` ### Nothing y Null - `Nothing` - Tipo inferior, sin valores - `Null` - Subtipo de todos los tipos referencia ```scala def error(message: String): Nothing = { throw new Exception(message) } ``` ## Unit `Unit` es el equivalente de Scala al void de Java: ```scala def printAndReturn(str: String): Unit = { println(str) } val result: Unit = println("Hello") ``` ## Operaciones Numericas ```scala val a = 10 val b = 3 // Aritmetica a + b // 13 a - b // 7 a * b // 30 a / b // 3 (division entera) a % b // 1 // Punto flotante val c = 10.0 val d = 3.0 c / d // 3.333... c % d // 1.0 // Conversiones de tipo val intToDouble: Double = a // 10.0 val doubleToInt: Int = c.toInt // 10 ``` ## Caracteres y Booleanos ```scala // Caracteres val c1: Char = 'A' val c2: Char = '\u0041' // Unicode val c3: Char = '\n' // Nueva linea // Booleano val isScalaFun = true val isJavaFun = false // Operaciones booleanas !isScalaFun // false isScalaFun && isJavaFun // false isScalaFun || isJavaFun // true ``` ## lazy val `lazy val` se evalua solo cuando se accede por primera vez: ```scala lazy val expensiveComputation = { println("Computing...") Thread.sleep(1000) 42 } println("Before") println(expensiveComputation) // Computing... luego 42 println(expensiveComputation) // Solo 42 (sin recalculo) ``` ### Cuando Usar lazy val - Calculos costosos - Recursos que podrian no ser necesarios - Dependencias circulares ## Alias de Tipos ```scala type Matrix = List[List[Double]] def invert(matrix: Matrix): Matrix = { // Operaciones de matriz matrix } ``` ## Regex y Emparejamiento de Patrones en Tipos ```scala val numberPattern = "^[0-9]+$".r "123" match { case numberPattern() => println("It's a number!") case _ => println("Not a number") } ``` ## Tuplas Las tuplas agrupan valores heterogeneos: ```scala val person: (String, Int, Boolean) = ("Alice", 30, true) // Acceso por indice (1-based) person._1 // Alice person._2 // 30 person._3 // true // Emparejamiento de patrones en tuplas val (name, age, isStudent) = person ``` ## Resumen - `val` crea enlaces inmutables; `var` crea mutables - Scala tiene Byte, Short, Int, Long, Float, Double, Char, Boolean, String, Unit - La inferencia de tipos reduce la verbosidad - `lazy val` difiere la evaluacion hasta el primer acceso - Todo es un objeto, incluyendo tipos basicos - Las tuplas agrupan valores heterogeneos - Prefiere inmutabilidad (val) sobre mutabilidad (var)