Variables, Tipos y Constantes

## Objetivos de Aprendizaje - Declarar y usar variables - Comprender los tipos de datos de Ruby - Trabajar con constantes - Dominar la conversion de tipos ## Variables ### Declaracion y Asignacion ```ruby edad = 25 # Entero nombre = "Ruby" # Cadena de texto precio = 19.99 # Flotante esta_activo = true # Booleano nada = nil # Nil (nulo) # Asignacion multiple x, y, z = 1, 2, 3 ``` ### Reglas de Nombres de Variables - Comenzar con letra minuscula o guion bajo - Pueden contener letras, numeros y guiones bajos - Distingue mayusculas de minusculas - No se pueden usar palabras reservadas ```ruby primer_nombre = "Juan" # Valido _contador = 0 # Valido miVar = "prueba" # Valido (pero no es convencion) 2do_lugar = "plata" # Invalido clase = "ruby" # Invalido (palabra reservada) ``` ## Tipos de Datos ### Entero ```ruby edad = 25 negativo = -10 hex = 0xFF # 255 en hexadecimal octal = 0755 # 493 en octal binario = 0b1010 # 10 en binario # Guiones bajos para legibilidad poblacion = 7_000_000_000 ``` ### Flotante ```ruby precio = 19.99 temperatura = -5.5 cientifico = 1.5e-3 # 0.0015 ``` ### Cadena de Texto ```ruby simple = 'Hola' # Comillas simples - literal doble = "Hola" # Comillas dobles - permite interpolacion interpolado = "Valor: #{2 + 2}" # "Valor: 4" # Cadena de multiples lineas poema = <<~TEXTO Las rosas son rojas, Las violetas son azules, Ruby es increible, Y tu tambien lo eres. TEXTO ``` ### Booleano ```ruby es_valido = true esta_vacio = false # Veracidad # valores falsy: false, nil # valores truthy: todo lo demas (0, "", [], etc.) ``` ### Nil ```ruby vacio = nil # Verificar si es nil if vacio.nil? puts "El valor es nil" end # Navegacion segura nombre = nil puts nombre&.upcase # nil en lugar de error ``` ## Constantes ```ruby TAMANO_MAXIMO = 100 PI = 3.14159 # Las constantes pueden modificarse pero Ruby advierte TAMANO_MAXIMO = 200 # Advertencia: constante ya inicializada ``` ## Simbolos Los simbolos son identificadores inmutables y reutilizables: ```ruby # Creacion de simbolos :pendiente :nombre_simbolo :"simbolo complejo" # vs Cadena de texto "pendiente" # Crea un nuevo objeto cada vez :pendiente # Mismo objeto, reutilizado # Uso comun: claves de hashes usuario = { nombre: "Alicia", edad: 30 } # Esto es equivalente a: usuario = { :nombre => "Alicia", :edad => 30 } ``` ## Conversion de Tipos ### A Cadena de Texto ```ruby edad = 25 puts edad.to_s # "25" puts edad.to_s.class # String # Entero a cadena de texto [1, 2, 3].join # "123" ``` ### A Entero ```ruby "42".to_i # 42 "42.9".to_i # 42 (trunca) "hola".to_i # 0 (no numerico se convierte a 0) "42".to_i(16) # 66 (hexadecimal a decimal) ``` ### A Flotante ```ruby "3.14".to_f # 3.14 "42".to_f # 42.0 ``` ### A Array ```ruby "hola".chars # ["h", "e", "l", "l", "o"] "uno,dos,tres".split(",") # ["uno", "dos", "tres"] ``` ### A Simbolo ```ruby "pendiente".to_sym # :pendiente :pendiente.to_s # "pendiente" ``` ## Verificacion de Tipos ```ruby valor = 42 valor.is_a?(Integer) # true valor.is_a?(String) # false valor.instance_of?(Integer) # true # Verificacion de tipo if valor.respond_to?(:to_s) puts valor.to_s end ``` ## Asignacion Paralela ```ruby # Intercambiar variables a, b = 1, 2 a, b = b, a puts "#{a}, #{b}" # "2, 1" # Operador rest primero, *resto = [1, 2, 3, 4, 5] puts primero # 1 puts resto # [2, 3, 4, 5] ``` ## Alcance de Variables ```ruby # Variable local - dentro de metodo/bloque def ejemplo local = "Soy local" puts local end # Variable de instancia - a traves de metodos en una clase class Usuario def initialize(nombre) @nombre = nombre # Variable de instancia end def saludar "Hola, #@nombre" end end # Variable de clase - compartida a traves de la jerarquia de clases class Contador @@conteo = 0 def initialize @@conteo += 1 end def self.total @@conteo end end ``` ## Resumen - Variables: no se necesita declaracion de tipo, se infiere de la asignacion - Enteros: Fixnum (heredado) y Bignum unificados como Integer - Cadenas de texto: Comillas dobles permiten interpolacion, comillas simples son literales - Simbolos: Identificadores inmutables, mas eficientes que las cadenas de texto - Constantes: MAYUSCULAS, Ruby advierte al reasignar - Conversion de tipos: `to_s`, `to_i`, `to_f`, `to_a`, `to_sym` - Truthy: todo excepto `false` y `nil`