Tutorial de Ruby para principiantes

Qué es Ruby y para qué se usa

Ruby fue creado por Yukihiro Matsumoto («Matz») en Japón y se publicó por primera vez en 1995, con el objetivo de hacer felices a los programadores. Se hizo muy conocido gracias a Ruby on Rails, el framework web que hay detrás de sitios como GitHub y Shopify. Ruby se usa en aplicaciones web, scripting y automatización, y en herramientas para desarrolladores como Homebrew y CocoaPods. Su implementación estándar es CRuby (también llamada MRI).

Instalar Ruby y ejecutar Hello, world

macOS y muchos sistemas Linux incluyen un Ruby, pero a menudo es antiguo; instala un Ruby 3 actual con un gestor de versiones como rbenv, asdf o mise, o con RubyInstaller en Windows. Compruébalo con ruby -v.

puts "Hello, world"

ruby hello.rb
# Hello, world
irb          # interactive Ruby shell

puts imprime un valor seguido de un salto de línea. Los paréntesis alrededor de los argumentos de un método son opcionales cuando el significado es claro.

Variables y tipos básicos

Las variables no necesitan declaración y contienen cualquier objeto. Por convención los nombres usan snake_case. Las constantes empiezan con mayúscula.

name = "Ada"
count = 7
puts "#{name} has #{count} items"   # Ada has 7 items
puts count / 2, count / 2.0         # 3, then 3.5
puts "12".to_i + 1                  # 13
puts 5.class, nil.to_a.inspect      # Integer, then []
puts 0 ? "0 is truthy" : "falsy"    # 0 is truthy

Control de flujo

score = 72
if score >= 90
  puts "A"
elsif score >= 70
  puts "B"          # B
else
  puts "C"
end

puts "pass" unless score < 50    # statement modifier

3.times { |i| print i, " " }     # 0 1 2
puts

n = 10
n /= 2 while n > 1
puts n                           # 1

kind = case "SAT"
       when "SAT", "SUN" then "weekend"
       else "weekday"
       end
puts kind                        # weekend

Los bloques terminan con end en lugar de llaves. El código Ruby suele indentarse con 2 espacios.

Métodos

Los métodos devuelven el valor de su última expresión, así que return suele ser innecesario. Por convención, los métodos que devuelven un booleano terminan en ?, y los que modifican el receptor en el sitio terminan en !.

def greet(name, greeting: "Hello")
  "#{greeting}, #{name}!"
end

def total(*nums)
  nums.sum
end

puts greet("Lin")                   # Hello, Lin!
puts greet("Lin", greeting: "Hi")   # Hi, Lin!
puts total(1, 2, 3)                 # 6
puts 4.even?, "abc".upcase          # true, then ABC

s = "hello"
s.upcase!          # modifies s in place
puts s             # HELLO

Arrays y hashes

nums = [3, 1, 2]
nums << 5
p nums.sort, nums.first, nums.last   # [1, 2, 3, 5] then 3 then 5
p nums.sort[1..2]                    # [2, 3]

ages = { "ann" => 31, "bob" => 25 }
ages["cy"] = 40
ages.each { |person, age| puts "#{person} is #{age}" }
p ages.fetch("zed", 0)               # 0

user = { name: "Ann", city: "Oslo" } # symbol keys
p user[:name]                        # "Ann"

p imprime la forma inspect de un valor, lo que resulta útil para depurar porque muestra comillas y corchetes.

Característica distintiva: bloques e iteradores

Un bloque es un fragmento de código que se pasa a un método, escrito con { ... } en una línea o con do ... end en varias. En Ruby la iteración se hace sobre todo con bloques en lugar de bucles for, y los métodos de Enumerable hacen que las transformaciones de datos sean cortas.

nums = [1, 2, 3, 4, 5]
p nums.map { |n| n * n }               # [1, 4, 9, 16, 25]
p nums.select(&:even?)                 # [2, 4]
p nums.reduce(0) { |sum, n| sum + n }  # 15
p nums.each_slice(2).to_a              # [[1, 2], [3, 4], [5]]
p %w[pear fig apple].sort_by(&:length) # ["fig", "pear", "apple"]

def twice
  yield
  yield
end
twice { puts "hi" }   # prints hi two times

&:even? es una forma abreviada de { |n| n.even? }. Tus propios métodos reciben un bloque y lo llaman con yield.

Clases y módulos

module Greeter
  def hello
    "Hello from #{name}"
  end
end

class Account
  include Greeter          # mix in module methods
  attr_reader :name, :balance

  def initialize(name)
    @name = name           # @ marks an instance variable
    @balance = 0
  end

  def deposit(amount)
    raise ArgumentError, "amount must be positive" unless amount.positive?
    @balance += amount
    self
  end

  def to_s = "#{name}: #{balance}"
end

acc = Account.new("Ann")
acc.deposit(30).deposit(20)
puts acc        # Ann: 50
puts acc.hello  # Hello from Ann

attr_reader genera métodos getter. Los módulos agrupan métodos que se pueden mezclar (mixin) en muchas clases, lo que Ruby usa en lugar de la herencia múltiple. La forma de una línea def to_s = ... requiere Ruby 3.0 o posterior.

Manejo de errores

def parse_age(text)
  age = Integer(text)       # raises ArgumentError on bad input
  raise ArgumentError, "negative age" if age.negative?
  age
end

begin
  puts parse_age("41")      # 41
  puts parse_age("abc")
rescue ArgumentError => e
  puts "error: #{e.message}"  # error: invalid value for Integer(): "abc"
ensure
  puts "done"
end

rescue captura excepciones y ensure se ejecuta siempre. Dentro de un método puedes escribir rescue directamente sin begin.

Un programa completo pequeño: frecuencia de palabras

path = ARGV.fetch(0) { abort "usage: ruby words.rb FILE" }

begin
  text = File.read(path).downcase
rescue Errno::ENOENT
  abort "file not found: #{path}"
end

counts = text.scan(/[a-z']+/).tally
counts.max_by(5) { |_word, n| n }.each do |word, n|
  puts format("%5d  %s", n, word)
end

Ejecútalo con ruby words.rb notes.txt. tally cuenta los elementos iguales en un hash y max_by(5) devuelve las cinco entradas con los recuentos más altos.

Errores comunes de principiantes

• Olvidar el end que cierra los bloques if, def, class o do.
• Mezclar claves de cadena y claves de símbolo: h["name"] y h[:name] son claves distintas.
• Usar comillas simples y esperar que funcione la interpolación #{}.
• Llamar a un método con ! sin darse cuenta de que cambió el objeto original.
• Usar el antiguo Ruby del sistema en lugar de una versión actual instalada con un gestor de versiones.

Adónde ir después

Empieza por la página de documentación de ruby-lang.org, incluida la guía rápida «Ruby in Twenty Minutes», y usa docs.ruby-lang.org como referencia del núcleo y de la biblioteca estándar. Aprende Bundler y las gems para las dependencias, RSpec o Minitest para las pruebas, y después Ruby on Rails si quieres crear aplicaciones web.