Entorno y sintaxis esencial de Ruby

Configurar un entorno mínimo para ejecutar Ruby

Para empezar a programar en Ruby solo necesitas: (1) Ruby instalado, (2) una terminal (consola) y (3) un editor de texto. El flujo de trabajo más común es: escribir un archivo .rb, ejecutarlo con ruby y leer la salida en consola.

Verificar que Ruby está disponible

Abre tu terminal y ejecuta:

ruby -v

Deberías ver una versión (por ejemplo, ruby 3.x.x). Si el comando no existe, instala Ruby con el método recomendado para tu sistema (por ejemplo, RubyInstaller en Windows, o un gestor de versiones como rbenv/asdf en macOS/Linux).

Tu primer script: archivo .rb → ejecutar → salida

1) Crea una carpeta de trabajo (opcional) y entra en ella.

mkdir ruby_practica
cd ruby_practica

2) Crea un archivo llamado hola.rb con este contenido:

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

puts "Hola, Ruby"

3) Ejecútalo:

ruby hola.rb

4) Observa la salida en consola:

Hola, Ruby

Idea clave: Ruby ejecuta el archivo de arriba hacia abajo. Lo que imprimes con puts aparece en la consola.

Sintaxis esencial: lo mínimo para escribir Ruby con claridad

Comentarios

Los comentarios sirven para documentar el código y Ruby los ignora al ejecutar.

• Comentario de una línea: empieza con #

# Esto es un comentario
puts "Se ejecuta"

• Bloque de comentarios (útil para desactivar secciones): =begin y =end

=begin
Esto es un bloque de comentario.
Ruby lo ignora.
=end
puts "Activo"

Convenciones de nombres (naming)

Ruby no te obliga, pero la comunidad sigue convenciones que hacen el código más legible:

• variables y métodos: snake_case (ej. total_compra, calcular_impuesto)
• clases y módulos: CamelCase (ej. Usuario, PagoOnline)
• constantes: MAYÚSCULAS (ej. IVA, API_URL)
• predicados: métodos que devuelven booleanos suelen terminar en ? (ej. vacio?)
• métodos “peligrosos”: a veces terminan en ! cuando modifican el objeto (ej. upcase!)

Literales comunes: números, strings y símbolos

Un literal es un valor escrito directamente en el código.

Números

• Enteros: 10, -3
• Decimales (Float): 3.14

puts 10 + 5      # 15
puts 10 / 4      # 2 (división entera)
puts 10.0 / 4    # 2.5 (Float)

Strings (cadenas)

En Ruby puedes usar comillas dobles o simples:

• "texto" permite interpolación y secuencias especiales
• 'texto' es más literal (no interpola)

puts "Hola\nRuby"   # incluye salto de línea
puts 'Hola\nRuby'   # imprime \n tal cual

Símbolos

Un símbolo es un identificador inmutable, muy usado como etiqueta o clave. Se escribe con : al inicio.

estado = :activo
puts estado

Comparación rápida (idea práctica): si necesitas una “etiqueta” repetida muchas veces, un símbolo suele ser más apropiado que un string.

Interpolación y concatenación de cadenas

Interpolación (solo con comillas dobles)

La interpolación inserta el resultado de una expresión dentro de un string con #{...}.

nombre = "Ana"
edad = 28
puts "Hola, #{nombre}. Tienes #{edad} años."

Dentro de #{} puedes poner expresiones:

precio = 19.99
cantidad = 3
puts "Total: #{precio * cantidad}"

Concatenación

Formas comunes de unir strings:

• + crea un nuevo string
• << agrega al string existente (mutación)

a = "Hola"
b = "Ruby"
puts a + " " + b         # "Hola Ruby"

c = "Hola"
c << " " << b
puts c                   # "Hola Ruby"

Expresiones y prioridad de operadores

En Ruby, casi todo es una expresión: produce un valor. Esto te permite escribir código compacto y claro.

x = 2 + 3 * 4
puts x

La prioridad (precedencia) importa: multiplicación y división se evalúan antes que suma y resta. En el ejemplo anterior, 3 * 4 ocurre primero.

Operadores comunes (resumen)

Cuando tengas dudas, usa paréntesis para forzar el orden y mejorar legibilidad:

resultado = (2 + 3) * 4
puts resultado  # 20

Conversiones básicas: to_i, to_f, to_s

Convertir tipos es habitual, especialmente al leer datos desde teclado (que llegan como string).

• to_i: convierte a entero
• to_f: convierte a float
• to_s: convierte a string

puts "42".to_i         # 42
puts "3.14".to_f       # 3.14
puts 123.to_s          # "123"

Nota práctica: "abc".to_i devuelve 0 porque no puede interpretar un número al inicio del string.

Ejercicios cortos (para practicar en consola)

Ejercicio 1: imprimir resultados

Crea ej1.rb e imprime el resultado de estas expresiones:

puts 7 + 5
puts 7 * 5
puts 7 / 5
puts 7.0 / 5

Pregunta: ¿por qué cambia el resultado entre 7 / 5 y 7.0 / 5?

Ejercicio 2: concatenar e interpolar

Crea ej2.rb:

nombre = "Luis"
ciudad = "Lima"

puts "Hola, " + nombre + "."
puts "Vives en #{ciudad}."
puts "#{nombre} vive en #{ciudad}."

Modifica el script para que el mensaje final incluya la longitud del nombre: nombre.length.

Ejercicio 3: conversiones básicas

Crea ej3.rb y completa:

entero = "10".to_i
float = "2.5".to_f
texto = 99.to_s

puts entero + 5       # ¿cuánto da?
puts float * 2
puts "Valor: " + texto

Extra: prueba qué pasa con "12abc".to_i y "abc12".to_i.

Mini-reto: script interactivo con entrada por teclado

Vas a construir un script que pida datos al usuario y devuelva un mensaje formateado. En Ruby, gets lee una línea desde teclado y normalmente incluye un salto de línea al final; por eso se usa chomp para quitarlo.

Paso a paso

1) Crea un archivo perfil.rb.

2) Escribe este código:

print "¿Cómo te llamas? "
nombre = gets.chomp

print "¿Cuántos años tienes? "
edad = gets.chomp.to_i

print "¿Cuál es tu ciudad? "
ciudad = gets.chomp

anio_nacimiento_aprox = Time.now.year - edad

puts "Hola, #{nombre}. Vives en #{ciudad} y naciste aproximadamente en #{anio_nacimiento_aprox}."

3) Ejecútalo:

ruby perfil.rb

4) Prueba distintas entradas (incluyendo edades con decimales o texto) y ajusta el script para manejarlo: por ejemplo, cambiar to_i por to_f si quieres permitir 18.5, o validar que la edad sea mayor que 0 antes de calcular.