Aprende Ruby en 10 minutos

8 October 2025 — Lenguaje De Programación

Ruby es un lenguaje de programación dinámico y orientado a objetos conocido por su sintaxis elegante y características amigables para desarrolladores. Este tutorial cubre los conceptos centrales de Ruby para ayudarte a aprender el lenguaje rápidamente.

1. Escribiendo tu primer programa en Ruby

Empecemos con un programa simple. Crea un archivo llamado hello.rb e ingresa el siguiente código:

puts "Hello, World!"

Guarda el archivo y ejecuta el siguiente comando en la terminal:

ruby hello.rb

La salida será:

Hello, World!

Este programa simple demuestra la funcionalidad básica de salida de Ruby. El método puts se usa para mostrar información de texto en la consola.

2. Sintaxis básica

La sintaxis de Ruby es limpia y legible, diseñada para ser natural e intuitiva.

# Esto es un comentario
puts "Hello, World!"

Reglas básicas de sintaxis en Ruby:

Comentarios: Los comentarios de una línea comienzan con #, mientras que los comentarios de múltiples líneas usan =begin y =end.
Sentencias: Típicamente una sentencia por línea, no se necesita punto y coma ; al final.
Bloques de código: Definidos por do...end o llaves {}.
Llamadas a métodos: Los paréntesis son opcionales para llamadas a métodos sin argumentos.

Ejemplo con comentarios de múltiples líneas:

=begin
Este es un comentario de múltiples líneas,
que abarca varias líneas.
=end

3. Variables y tipos de datos

En Ruby, las variables son tipadas dinámicamente y no requieren declaraciones de tipo explícitas.

Reglas básicas de nomenclatura de variables:

Los nombres de variables solo pueden contener letras, números y guiones bajos.
Los nombres de variables no pueden comenzar con un número.
Los nombres de variables distinguen entre mayúsculas y minúsculas.
Las palabras clave de Ruby no pueden usarse como nombres de variables.

Los principales tipos de datos básicos de Ruby son:

Entero (Integer): por ejemplo, 42 o -10.
Flotante (Float): por ejemplo, 3.14 o 2.5e3.
Cadena (String): por ejemplo, "hello" o 'world', usando comillas simples o dobles.
Booleano (Boolean): true o false.
Nil (Nil): Representado por nil, indica nulo o sin valor.
Símbolo (Symbol): por ejemplo, :name, identificadores inmutables.

3.1 Tipos numéricos

Ruby soporta enteros y números de punto flotante.

# Entero
age = 25
population = 1_000_000  # Guiones bajos para legibilidad

# Flotante
temperature = 36.5
pi = 3.14159

# Operaciones
puts 10 + 5   # 15
puts 10 / 3   # 3 (división entera)
puts 10.0 / 3 # 3.333... (división flotante)

3.2 Cadenas

Las cadenas son secuencias de caracteres, encerradas en comillas simples o dobles.

single_quote = 'Cadena con comillas simples'
double_quote = "Cadena con comillas dobles"
multiline = "Esta es una
cadena de múltiples líneas"

# Interpolación de cadenas (solo en comillas dobles)
name = "Alice"
greeting = "Hello, #{name}!"
puts greeting  # "Hello, Alice!"

Operaciones con cadenas:

text = "Ruby programming"
puts text.length        # Longitud de la cadena
puts text.upcase        # Convertir a mayúsculas
puts text.downcase      # Convertir a minúsculas
puts text[0]            # Acceder al primer carácter
puts text[0..3]         # Segmentación de cadena
puts text.include?("Ruby")  # Verificar inclusión

3.3 Tipo booleano

El tipo booleano tiene dos valores: true y false.

is_active = true
is_complete = false

# Operaciones booleanas
result1 = true && false  # false
result2 = true || false  # true
result3 = !true          # false

3.4 Tipo Nil

nil representa un estado nulo o sin valor.

value = nil

if value.nil?
  puts "El valor es nulo"
end

3.5 Símbolos

Los símbolos son identificadores inmutables, frecuentemente usados como claves en hashes.

:name
:email
:created_at

# Símbolos vs Cadenas
puts :name.object_id == :name.object_id  # true (mismo objeto)
puts "name".object_id == "name".object_id  # false (objetos diferentes)

4. Estructuras de datos

Ruby proporciona varias estructuras de datos integradas para almacenar y manipular datos.

4.1 Array

Un array es una colección ordenada que puede contener múltiples valores.

numbers = [1, 2, 3, 4, 5]
numbers.push(6)        # Agregar elemento
numbers.unshift(0)     # Insertar al principio
numbers.delete(3)      # Eliminar valor específico
numbers[0] = 10        # Modificar elemento
puts numbers.inspect   # [10, 2, 4, 5, 6]

Operaciones con arrays:

numbers = [10, 20, 30, 40, 50]
puts numbers[1..3]     # [20, 30, 40]
puts numbers.first     # 10
puts numbers.last      # 50
puts numbers.include?(30)  # true

4.2 Hash

Un hash es una colección de pares clave-valor, similar a diccionarios en otros lenguajes.

student = {
  name: "John",
  age: 20,
  major: "Computer Science"
}

# Accediendo y modificando hash
puts student[:name]
student[:age] = 21
student[:gpa] = 3.8

# Iterando sobre hash
student.each do |key, value|
  puts "#{key}: #{value}"
end

5. Control de flujo

Ruby proporciona varias sentencias de control de flujo para gestionar la ejecución del programa.

5.1 Sentencias if

La sentencia if evalúa una condición y ejecuta su bloque si la condición es verdadera.

age = 20
if age >= 18
  puts "Adulto"
elsif age >= 13
  puts "Adolescente"
else
  puts "Niño"
end

# if de una línea
puts "Adulto" if age >= 18

5.2 Sentencias unless

unless es lo opuesto a if - ejecuta cuando la condición es falsa.

age = 15
unless age >= 18
  puts "No es adulto"
end

# unless de una línea
puts "No es adulto" unless age >= 18

5.3 Sentencias case

Las sentencias case proporcionan una forma limpia de manejar múltiples condiciones.

grade = "B"

case grade
when "A"
  puts "Excelente"
when "B"
  puts "Bueno"
when "C"
  puts "Promedio"
else
  puts "Necesita mejorar"
end

5.4 Bucles

Ruby soporta varios constructos de bucle.

Bucle while:

count = 0
while count < 5
  puts count
  count += 1
end

Bucle until:

count = 0
until count >= 5
  puts count
  count += 1
end

Bucle for:

for i in 0..4
  puts i
end

Iterador each:

(0..4).each do |i|
  puts i
end

# Con arrays
fruits = ["apple", "banana", "cherry"]
fruits.each do |fruit|
  puts fruit
end

break y next:

(0..9).each do |i|
  break if i == 5     # Salir del bucle
  next if i % 2 == 0  # Saltar números pares
  puts i              # Salida: 1, 3
end

6. Métodos

Los métodos en Ruby se definen usando la palabra clave def.

Definición básica de método:

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

# Llamando al método
message = greet("John")
puts message

Parámetros por defecto:

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

puts greet("Alice")          # "Hello, Alice!"
puts greet("Bob", "Hi")      # "Hi, Bob!"

Argumentos variables:

def sum_numbers(*numbers)
  numbers.sum
end

puts sum_numbers(1, 2, 3, 4)  # 10

Argumentos de palabra clave:

def create_person(name:, age:, city: "Unknown")
  { name: name, age: age, city: city }
end

person = create_person(name: "Alice", age: 25)
puts person.inspect

7. Bloques y Procs

Los bloques son fragmentos de código que pueden pasarse a métodos.

Usando bloques:

# Usando do...end
3.times do
  puts "Hello!"
end

# Usando llaves
3.times { puts "Hello!" }

# Bloques con parámetros
(1..3).each do |number|
  puts "Number: #{number}"
end

Palabra clave Yield:

def run_block
  puts "Antes del bloque"
  yield
  puts "Después del bloque"
end

run_block { puts "Dentro del bloque" }

Procs:

Los Procs son objetos que encapsulan bloques.

square = Proc.new { |x| x * x }
puts square.call(5)  # 25

# Pasando procs a métodos
def apply_operation(numbers, operation)
  numbers.map { |n| operation.call(n) }
end

numbers = [1, 2, 3, 4]
squares = apply_operation(numbers, square)
puts squares.inspect  # [1, 4, 9, 16]

8. Clases y objetos

Ruby es un lenguaje puramente orientado a objetos donde todo es un objeto.

Definición básica de clase:

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end

  def introduce
    "I am #{@name}, #{@age} years old"
  end

  def have_birthday
    @age += 1
    "#{@name} had a birthday, now #{@age} years old"
  end
end

# Creando objetos
person1 = Person.new("John", 25)
person2 = Person.new("Jane", 30)

puts person1.introduce
puts person2.have_birthday

Métodos de acceso:

class Person
  attr_reader :name    # Acceso de lectura
  attr_writer :age     # Acceso de escritura
  attr_accessor :city  # Acceso de lectura y escritura

  def initialize(name, age, city)
    @name = name
    @age = age
    @city = city
  end
end

person = Person.new("Alice", 25, "New York")
puts person.name      # "Alice"
person.age = 26       # Establecer edad
person.city = "Boston" # Establecer ciudad
puts person.city      # "Boston"

Métodos de clase y variables:

class Student
  @@student_count = 0  # Variable de clase

  def initialize(name)
    @name = name
    @@student_count += 1
  end

  def self.student_count  # Método de clase
    @@student_count
  end
end

student1 = Student.new("John")
student2 = Student.new("Jane")
puts Student.student_count  # 2

Herencia:

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    "#{@name} makes a sound"
  end
end

class Dog < Animal
  def speak
    "#{@name} barks"
  end
end

class Cat < Animal
  def speak
    "#{@name} meows"
  end
end

dog = Dog.new("Buddy")
cat = Cat.new("Mimi")

puts dog.speak  # "Buddy barks"
puts cat.speak  # "Mimi meows"

9. Módulos y Mixins

Los módulos se usan para agrupar métodos y constantes relacionados, y pueden mezclarse en clases.

Definición de módulo:

module Speakable
  def speak
    "#{@name} says something"
  end
end

class Person
  include Speakable

  def initialize(name)
    @name = name
  end
end

person = Person.new("Alice")
puts person.speak  # "Alice says something"

Espacios de nombres con módulos:

module Math
  PI = 3.14159

  def self.square(x)
    x * x
  end
end

puts Math::PI        # 3.14159
puts Math.square(5)  # 25

10. Manejo de excepciones

Ruby proporciona un manejo robusto de excepciones usando begin, rescue, ensure y raise.

Manejo básico de excepciones:

begin
  result = 10 / 0
rescue ZeroDivisionError => e
  puts "No se puede dividir por cero: #{e.message}"
else
  puts "División exitosa"
ensure
  puts "Esto siempre se ejecuta"
end

Lanzando excepciones:

def divide(a, b)
  raise "No se puede dividir por cero" if b == 0
  a / b
end

begin
  result = divide(10, 0)
rescue => e
  puts "Error: #{e.message}"
end

11. Operaciones con archivos

Ruby proporciona métodos simples para leer y escribir archivos.

Leyendo archivos:

# Leer archivo completo
content = File.read("example.txt")
puts content

# Leer línea por línea
File.foreach("example.txt") do |line|
  puts line.chomp
end

Escribiendo archivos:

# Escribir en archivo
File.write("output.txt", "Hello, Ruby!\n")

# Anexar a archivo
File.open("output.txt", "a") do |file|
  file.puts "Anexando nuevo contenido."
end

12. Métodos integrados útiles

Ruby viene con muchos métodos integrados útiles.

Métodos de cadena:

text = "  Ruby Programming  "
puts text.strip        # Eliminar espacios en blanco
puts text.split(" ")   # Dividir en array
puts text.gsub("Ruby", "Python")  # Reemplazar

Métodos de array:

numbers = [3, 1, 4, 1, 5, 9, 2]
puts numbers.sort.inspect      # [1, 1, 2, 3, 4, 5, 9]
puts numbers.uniq.inspect      # [3, 1, 4, 5, 9, 2]
puts numbers.select { |n| n > 3 }.inspect  # [4, 5, 9]

Métodos de hash:

person = { name: "Alice", age: 25, city: "New York" }
puts person.keys.inspect    # [:name, :age, :city]
puts person.values.inspect  # ["Alice", 25, "New York"]
puts person.has_key?(:age)  # true

13. Ruby Gems

RubyGems es el administrador de paquetes de Ruby para instalar y gestionar bibliotecas.

Instalando Gems:

gem install rails

Usando Gems en código:

require 'json'

# Analizar JSON
json_string = '{"name": "Alice", "age": 25}'
person = JSON.parse(json_string)
puts person["name"]  # "Alice"

# Generar JSON
person_hash = { name: "Bob", age: 30 }
json_output = JSON.generate(person_hash)
puts json_output  # {"name":"Bob","age":30}

14. Guía de estilo de Ruby

Ruby tiene una guía de estilo de comunidad sólida que promueve código limpio y legible.

Indentación: Usa 2 espacios para la indentación.

Convenciones de nomenclatura:

Variables y métodos: snake_case
Clases y módulos: CamelCase
Constantes: SCREAMING_SNAKE_CASE

Paréntesis: Usa paréntesis para llamadas a métodos con argumentos, omítelos para llamadas a métodos sin argumentos.

Bloques: Usa do...end para bloques de múltiples líneas, {} para bloques de una línea.

La sintaxis elegante y las características poderosas de Ruby lo convierten en un placer para trabajar. Su enfoque en la felicidad y productividad del desarrollador lo ha hecho popular para desarrollo web, scripting y tareas de automatización.