Ruby es un lenguaje de programación creado por Matz en 1995, es open source y fue popularizado por Rails en 2005. Este lenguaje es dinámico, interpretado y orientado a objetos (todo es un objeto). Su objetivo es la felicidad y productividad del desarrollador.
Ventajas
- Comunidad muy grande
- Muchas librerías
- Constantes actualizaciones
- Lenguaje maduro
Desventajas
- Interpretado puede significar lento
- Alto uso de memoria
- No paralelismo
- Ha venido decreciendo en popularidad
Las variables son espacios reservados en la memoria que, como su nombre indica, pueden cambiar de contenido a lo largo de la ejecución de un programa.
Para declarar una variable escribimos el nombre de la variable, utilizar el operador igual “”="" y luego el valor que será asignado a esa variable.
Existen diferentes tipos de datos: el Integer o entero que puede representar un subconjunto finito de los números enteros y el Float o real que es la representación de un real estándar.
x = 5
x.class
x.methods
x.odd?
x.even?
Cuando son operaciones aritméticas y quieras retornar un float debes debes volver alguna de las variables de punto flotante.
4/5.0
0.80
Se ocupa %q para declarar variables que pueden tener comillas dentro.
saludo = "Hola"
saludo = %q(Hola)
Capacidad de cambiar una variable dentro de un string, esto se implementa por medio de #{}
nombre = "Pepe"
saludo = "Hola #{nombre}"
nombre.upcase
nombre.downcase
nombre.length
Ejemplo: Mi = mI
nombre.swapcase
si la variable nombre incluye la letra g.
Las interrogantes se representan por medio de ?
nombre.include? "g"
nombre.strip
nombre.empty?
nombre.gsub("busca", "remplaza por")
nombre.gsub!(“simon”,“pepe”)
Los symbols son un tipo de dato especial que utiliza Ruby para declarar constantes, esto existe para evitar que se generen más objetos y por lo tanto, no generar espacio de memoria adicional.
Para declarar un símbolo se utilizan los dos puntos “”:"", ejemplo:
color = :rojo
Se convierten a string de esta forma. Se asegura de siempre usar la misma instancia de memoria.
:rojo.to_s
Todo objeto cuenta con un id y este se visualiza de la siguiente forma.
Objeto.object_id
Un array o arreglo es un tipo de datos especial donde vas a poder almacenar múltiples objetos en una sola variable. Son débil mente tipados.
Ejemplo:
letras = [ ""q"", ""w"", ""e"", ""r"", ""t"", ""y""]
Algo interesante de Ruby es que podemos utilizar números negativos para acceder a las posiciones desde el último elemento del array.
Los arreglos en Ruby no tienen un tipo específico, esto quiere decir que dentro de un array podemos tener diferentes tipos de datos en cada elemento.
Donde suponemos que tenemos un Array V.
v.size
Donde los valores posibles son del -Infinito al +Infinito.
v[0]
v.include? "valor"
v.first
v.last
v.min
v.max
v.sum
Separa una cadena por espacio por ejemplo.
cadena.split(" ")
v.sort
Hashes, también conocidos como arrays asociativos, mapas o diccionarios, son parecidos a los arrays en que son una colección indexada de referencias a objetos. Sin embargo, mientras que en los arrays los índices son números, en los hashes se puede indexar con objetos de cualquier tipo.
Cuando se almacena un valor en un array, se dan dos objetos: el índice y el valor. Luego, se puede obtener dicho valor, gracias al índice.
Ejecuta estas líneas en irb
para ver el resultado de cada instrucción.
capitales = {
"Mexico" => "Ciudad de Mexico",
"Colombia" => "Bogota",
"Peru" => "Lima",
"Chile" => "Santiago de Chile",
"España" => "Madrid",
"Argentina" => "Buenos aires",
"Paises bajos" => "Amsterdam",
"Estados Unidos" => "Washington"
}
capitales["Colombia"]
capitales["Argentina"]
capitales["Marte"] = "Elon"
capitales.size
capitales.empty?
capitales.has_value? "Washington"
capitales.invert
capitales.merge({"Alemania" => "Berlin", "Francia" => "Paris"})
capitales.transform_values { |v| v.downcase }
{}.class
{}.methods
[["pepito", 13], ["sutanito", 30], ["fulanito", 2]].to_h
Dentro de las condiciones esta el clásico if, mientras que cuando es necesario poner una sentencia con mas de 2 bloques se recomienda usar elsif.
Para condiciones que no se cumplen y si solo queda una opción se ocupa else. Y es muy importante que cuando se hace una bloque condicional o un loop se cierre con un end
# Condiciones
role = :user
is_authenticated = false
if role == :admin
puts "Pantalla de admin"
elsif role == :superadmin
puts "Pantalla de superadmin"
else
puts "Pantalla de login"
end
x = 1
while x<5 do
puts "hola #{x}"
x+=1
end
En este caso no existe el do while pero si se puede hacer un do que es un ciclo infinito que termina si la condición se cumple gracias al break.
loop do
puts "hola #{x}"
x+= 1
break if x >=5
end
Donde un range se especifica como 1..4 es decir del 1 al 4.
for i in 1..4 do
puts "hola #{i}"
end
[1,2,3,4].each { |x| puts "hola #{x}" }
Esta iteración hace la lambda esto por 4 veces desde el 0 hasta el 3.
4.times { |x| puts "hola #{x}" }
Rangos, el principal uso y quizás el más apropiado para los rangos, es expresar una secuencia: las secuencias tienen un punto inicial y un punto final, y una forma de producir los sucesivos valores entre ambos. En Ruby, esas secuencias son creadas usando los operandos '…' y '…'
Este tipo de rango hace una iteración del 1 al 6.
(1..6)
Este tipo de rango solo itera del 1 al 5 es decir excluye el limite derecho.
(1...6)
Aplicando el método to_a se convierte un rango a un array.
(1..6).to_a
(1..6).include? 3
También se pueden hacer arreglos de letras.
('a'..'d').to_a
('a'...'d').to_a
Regex es un tema amplio y complejo, es por esto que en Platzi hemos creado un curso enfocado 100% en Expresiones Regulares, te invitamos a tomarlo.
Para declarar un regex, se utiliza el “”/"" , ejemplo:
Regex donde verificamos si un correo corresponde o es gmail.com. En caso de que coincida va a mandar un objeto tipo MatchData y si no encuentra coincidencia mandara un nil.
is_gmail_regex = /\w[email protected]/
"[email protected]".match /\w[email protected]/
"[email protected]".match? /\w[email protected]/
"[email protected]" =~ /\w[email protected]/
Si contiene digitos.
# Multiples matches
number_regex = /\d+/
"calle falsa 123 - 192".scan number_regex
Son evaluaciones o funciones orientadas a la programación funcional.
# Procs y Lambdas
saludar = Proc.new { |nombre| puts "Hola #{nombre}" }
saludar.call("Simon")
class Transaction
def exec
puts "ejecutando transaccion"
if block_given?
yield
end
end
end
tx = Transaccion.new
tx.exec { puts "despues de la transaccion" }
Donde el constructor se declara mor medio del método initialize.
Los getters no necesitan return ya que por cada método generado este retornara el ultimo valor que tenga antes del end.
Mientras que los setters necesitan la sintaxis def age=(age) para poder asignar valores mediante el operador = y esta retorna a self para poder hacer múltiples agregaciones al mismo tiempo.
Donde si el setter retorna la instancia del objeto se podrá hacer una asignación. Por ejemplo
(persona.name).age = 7
class Persona
def self.suggested_name
["Pepe", "Pepito", "Sutano"]
end
def initialize(name, age)
@name = name
@age = age
end
def name
@name
end
def age
@age
end
def name=(name)
@name = name
self
end
def age=(age)
@age = age
self
end
end
persona = Persona.new("Pepe", 14)
puts persona.name
puts persona.age
puts Persona.suggested_name
Generación de setters y getters con attr_accessor :name, :age.
Este macro nos permite generar rápidamente atributos de la clase.
class Persona
attr_accessor :name, :age
def self.suggested_names
["Pepe", "Pepito", "Sutano"]
end
def initialize(name, age)
@name = name
@age = age
end
end
persona = Persona.new("Pepe", 14)
puts persona.name
puts persona.age
puts Persona.suggested_names
Al declarar una clase con Struct se genera el constructor y los getter y setters.
class Persona < Struct.new(:name, :age)
def self.suggested_names
["Pepe", "Pepito", "Sutano"]
end
end
persona = Persona.new("Pepe", 14)
puts persona.name
puts persona.age
puts Persona.suggested_names
Una buena práctica de programación es la modularización del código, lo que algunos llaman alta cohesión, lo que quiere decir que las clases o funcionalidades que hacen cosas similares estén dentro del mismo contenedor; en Ruby se utilizan los módulos para ello.
# Modules
module Model
class Company
end
class Employee
end
end
module Reports
class ExcelReporter
def build
puts "Generating excel report"
end
end
class EmailReporter
end
end
excel_report = Reports::ExcelReporter.new
excel_report.build
Para acceder a una clase que esta dentro de un modulo se ocupa el operador ::