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 ::