Operadores

## Objetivos de Aprendizaje - Usar operadores aritmeticos - Trabajar con operadores de comparacion - Comprender operadores logicos - Dominar la asignacion paralela ## Operadores Aritmeticos ```ruby a, b = 10, 3 puts a + b # 13 (suma) puts a - b # 7 (resta) puts a * b # 30 (multiplicacion) puts a / b # 3 (division entera) puts a % b # 1 (modulo - residuo) puts a ** b # 1000 (exponenciacion) ``` ### Comportamiento de la Division ```ruby puts 10 / 3 # 3 (division entera) puts 10.to_f / 3 # 3.333... (division flotante) puts 10.fdiv(3) # 3.333... (division flotante) # La division entera trunca hacia cero puts -10 / 3 # -3 ``` ### Modulo vs Residuo ```ruby puts 10 % 3 # 1 puts -10 % 3 # 2 (Ruby asegura: a % b tiene el mismo signo que b) puts 10.modulo(3) # 1 # Usar .remainder para truncar hacia cero puts -10.remainder(3) # -1 ``` ## Operadores de Comparacion ```ruby puts 5 == 5 # true (igualdad) puts 5 == "5" # false (tipo diferente) puts 5.eql?(5.0) # false (Integer vs Float) puts 5.equal?(5) # true (mismo objeto) puts 5 != 3 # true (no igual) puts 5 < 5 # false puts 5 <= 5 # true puts 5 > 3 # true puts 5 >= 5 # true ``` ### Operador Nave Espacial ```ruby # Retorna -1, 0 o 1 puts 5 <=> 5 # 0 (igual) puts 5 <=> 3 # 1 (izquierda es mayor) puts 3 <=> 5 # -1 (derecha es mayor) # Comunmente usado para ordenamiento [3, 1, 2].sort # [1, 2, 3] ``` ### Operador de Igualdad de Caso ```ruby # Usado en sentencias case/when (1..10) === 5 # true (5 esta en el rango 1-10) /String/ === "Hello" # true (coincidencia de patron) # Verificacion de modulo/clase String === "hello" # true (hello es un String) ``` ## Operadores Logicos ```ruby # Y puts true && true # true puts true && false # false puts true and false # true (menor precedencia) # O puts true || false # true puts false || false # false puts false or true # true (menor precedencia) # NO puts !true # false puts not true # false (menor precedencia) ``` ### Evaluacion de Cortocircuito ```ruby # && retorna el primer valor falsy o el ultimo valor puts nil && "hola" # nil puts false && "hola" # false puts 5 && "hola" # "hola" # || retorna el primer valor truthy o el ultimo valor puts 5 || nil # 5 puts nil || false # false puts nil || 5 # 5 ``` ### Patrones Utiles ```ruby # Establecer valor por defecto nombre = nil nombre_display = nombre || "Anonimo" # Ejecucion condicional es_valido && realizar_accion # Clausula de guardia def procesar(datos) return unless datos # procesar... end ``` ## Operadores Bit a Bit ```ruby a, b = 5, 3 # Binario: 101 y 011 puts a & b # 1 (Y: 001) puts a | b # 7 (O: 111) puts a ^ b # 6 (XO: 110) puts ~a # -6 (NO) puts a << 1 # 10 (desplazamiento a la izquierda) puts a >> 1 # 2 (desplazamiento a la derecha) ``` ## Operadores Unarios ```ruby puts +5 # 5 (positivo) puts -5 # -5 (negativo) puts --5 # 5 (doble negativo) puts !!!true # false (no no no) ``` ## Operadores de Asignacion ```ruby x = 10 x += 5 # x = x + 5 = 15 x -= 3 # x = x - 3 = 12 x *= 2 # x = x * 2 = 24 x /= 4 # x = x / 4 = 6 x %= 4 # x = x % 4 = 2 x **= 2 # x = x ** 2 = 36 ``` ## Asignacion Paralela ```ruby # Asignacion multiple a, b, c = 1, 2, 3 puts "#{a}, #{b}, #{c}" # "1, 2, 3" # Intercambiar sin variable temporal x, y = 1, 2 x, y = y, x puts "#{x}, #{y}" # "2, 1" # Operador rest cabeza, *cola = [1, 2, 3, 4, 5] puts cabeza # 1 puts cola # [2, 3, 4, 5] # Ignorar valores primero, _, tercero = [10, 20, 30] puts "#{primero}, #{tercero}" # "10, 30" # Operador splat numeros = [1, 2, 3] puts [*numeros, 4, 5] # [1, 2, 3, 4, 5] ``` ## Asignacion Encadenada ```ruby a = b = c = 0 a += 1 puts "#{a}, #{b}, #{c}" # "1, 0, 0" ``` ## Operadores de Rango ```ruby # Rango inclusivo (1..5).to_a # [1, 2, 3, 4, 5] # Rango exclusivo (1...5).to_a # [1, 2, 3, 4] # Usado en sentencias case def calificacion(puntaje) case puntaje when 90..100 then "A" when 80..89 then "B" when 70..79 then "C" else "F" end end ``` ## Precedencia de Operadores ```ruby # De mayor a menor: # 1. :: (resolucion de ambito) # 2. [] (acceso a array/hash) # 3. ** (exponenciacion) # 4. + - unarios # 5. * / % # 6. + - # 7. << >> # 8. & (Y bit a bit) # 9. | ^ (O bit a bit / XO) # 10. > >= < <= # 11. <=> == === != =~ !~ # 12. && (Y logico) # 13. || (O logico) # 14. .. ... (rango) # 15. ? : (ternario) # 16. = += -= etc. # 17. defined? # 18. not # 19. and or (baja precedencia) # 20. if unless while until (modificadores) ``` ### Ejemplos ```ruby # Sin parentesis puts 2 + 3 * 4 # 14 (no 20) puts (2 + 3) * 4 # 20 # Ternario con operadores logicos puts true && false ? "si" : "no" # "no" ``` ## Resumen - Aritmeticos: `+`, `-`, `*`, `/`, `%`, `**` - Comparacion: `==`, `!=`, `<`, `>`, `<=`, `>=`, `<=>`, `===` - Logicos: `&&`, `||`, `!`, `and`, `or`, `not` - Asignacion: `=`, `+=`, `-=`, `*=`, `/=`, etc. - Nave espacial `<=>` retorna -1, 0 o 1 - La asignacion paralela permite intercambio sin variable temporal - Precedencia: usa parentesis para clarificar la intencion