Hoja de Trucos de Ruby
Última actualización
Hola Mundo y ejecutar código
Ruby no necesita código repetitivo: una sola línea se ejecuta.
| Operación | Sintaxis |
|---|---|
| Imprimir con salto de línea | puts "Hello, World!" |
| Imprimir sin salto de línea | print "Hello" |
| Inspeccionar un valor | p [1, 2, 3] |
| Interpolación de cadenas | puts "Hi #{name}" |
| Comentario | # this is a comment |
| Comentario de varias líneas | =begin ... =end |
| Ejecutar un archivo | ruby app.rb |
| Shell interactiva | irb |
Variables y tipos
Ruby es de tipado dinámico; todo es un objeto.
| Operación | Sintaxis |
|---|---|
| Variable local | age = 30 |
| Constante | PI = 3.14 |
| Variable de instancia | @name = "Ada" |
| Variable global | $count = 0 |
| Símbolo | :status |
| Nil / booleano | nil, true, false |
| Comprobar el tipo | 42.class devuelve Integer |
| Convertir el tipo | "42".to_i, 42.to_s, "3.5".to_f |
Cadenas
Las cadenas son objetos mutables con un amplio conjunto de métodos.
| Operación | Sintaxis |
|---|---|
| Longitud | "hello".length |
| Mayúsculas / minúsculas | s.upcase, s.downcase |
| Quitar espacios | s.strip |
| Reemplazar | s.gsub("a", "b") |
| Dividir en un array | "a,b,c".split(",") |
| Incluye una subcadena | s.include?("ell") |
| Cortar caracteres | s[0..2] |
| Concatenar | "foo" + "bar", s << "!" |
| Repetir | "ab" * 3 |
| Dar formato | format("%05d", 42) |
Arrays
Colecciones ordenadas e indexadas por enteros.
| Operación | Sintaxis |
|---|---|
| Crear | nums = [1, 2, 3] |
| Acceder por índice | nums[0], nums[-1] |
| Añadir al final | nums.push(4), nums << 4 |
| Quitar del final | nums.pop |
| Longitud | nums.length |
| Map | nums.map { |n| n * 2 } |
| Filtrar | nums.select { |n| n.even? } |
| Reducir | nums.reduce(0) { |sum, n| sum + n } |
| Ordenar | nums.sort |
| Unir en una cadena | nums.join(", ") |
Hashes
Colecciones clave-valor, a menudo indexadas por símbolos.
| Operación | Sintaxis |
|---|---|
| Crear | user = { name: "Ada", age: 30 } |
| Acceder a un valor | user[:name] |
| Establecer un valor | user[:email] = "a@x.com" |
| Comprobar una clave | user.key?(:name) |
| Eliminar una clave | user.delete(:age) |
| Claves / valores | user.keys, user.values |
| Iterar | user.each { |k, v| puts "#{k}: #{v}" } |
| Valor por defecto | Hash.new(0) |
| Combinar | h1.merge(h2) |
Control de flujo
Condicionales y bucles; observa los modificadores al final de línea de Ruby.
| Operación | Sintaxis |
|---|---|
| If / elsif / else | if x > 0 ... elsif x < 0 ... else ... end |
| If en línea (modificador) | puts "hi" if ready |
| Unless | unless done ... end |
| Ternario | x > 0 ? "pos" : "neg" |
| Case / when | case n; when 1 then ...; else ...; end |
| Bucle while | while i < 10 ... end |
| Bucle until | until done ... end |
| Times | 5.times { |i| puts i } |
| Iteración sobre un rango | (1..5).each { |i| puts i } |
| Break / next | break, next |
Métodos
La última expresión se devuelve de forma implícita.
| Operación | Sintaxis |
|---|---|
| Definir un método | def add(a, b) ... end |
| Retorno implícito | def square(x) x * x end |
| Argumento por defecto | def greet(name = "World") ... end |
| Argumentos con nombre | def box(w:, h:) ... end |
| Splat (variádico) | def sum(*nums) ... end |
| Método que termina en ? | def valid? ... end |
| Método que termina en ! | def normalize! ... end |
| Llamar sin paréntesis | greet "Ada" |
Bloques, procs y lambdas
Los bloques son fragmentos de código que se pasan a los métodos; los procs y las lambdas los almacenan.
| Operación | Sintaxis |
|---|---|
| Bloque (llaves) | [1, 2].each { |n| puts n } |
| Bloque (do/end) | [1, 2].each do |n| puts n end |
| Ceder a un bloque | def run; yield; end |
| Comprobar si se dio un bloque | block_given? |
| Capturar el bloque como parámetro | def run(&blk); blk.call; end |
| Crear un proc | square = proc { |x| x * x } |
| Crear una lambda | square = ->(x) { x * x } |
| Llamar a un proc / lambda | square.call(3), square.(3) |
Clases y módulos
Las clases contienen estado y comportamiento; los módulos incorporan métodos compartidos.
| Operación | Sintaxis |
|---|---|
| Definir una clase | class Point ... end |
| Constructor | def initialize(x, y) @x = x; @y = y; end |
| Método de instancia | def dist ... end |
| Atajos de acceso | attr_accessor :x, :y |
| Crear una instancia | p = Point.new(1, 2) |
| Heredar | class Circle < Shape ... end |
| Método de clase | def self.origin ... end |
| Definir un módulo | module Drawable ... end |
| Incorporar un módulo | include Drawable |
| Llamar a super | super(args) |
La sintaxis de Ruby que más usas, en una sola página. Esta hoja de trucos de Ruby es una referencia rápida para el núcleo del lenguaje: variables y tipos, cadenas, arrays y hashes, control de flujo, métodos y los bloques, procs y lambdas que hacen a Ruby tan expresivo.
Todo lo que hay aquí es Ruby puro y se ejecuta en cualquier intérprete estándar. Copia lo que necesites o prueba cada fragmento en vivo en el playground de Ruby, sin necesidad de instalar nada.
Preguntas frecuentes sobre la hoja de trucos de Ruby
¿Esta hoja de trucos de Ruby es gratis?
Sí. Esta hoja de trucos de Ruby es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar un método de cadenas, una operación de hash o la sintaxis de un bloque.
¿Cuál es la diferencia entre un bloque, un proc y una lambda?
{ ... } o do ... end; no es un objeto por sí mismo. Un proc envuelve un bloque en un objeto invocable que puedes almacenar y pasar. Una lambda es un proc especial que comprueba estrictamente su número de argumentos y trata return como un retorno de la propia lambda, mientras que un proc normal retorna del método que lo contiene.¿Qué son los símbolos en Ruby?
:name es un identificador inmutable y reutilizable. Como el mismo símbolo siempre apunta al mismo objeto en memoria, los símbolos son más rápidos y eficientes en memoria que las cadenas para cosas como las claves de hash y los nombres de métodos, por eso a menudo ves hashes escritos como { name: "Ada" }.¿Puedo practicar Ruby en línea?
Sí. Abre el playground de Ruby para ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin necesidad de instalar Ruby. Cuando quieras estructura, el curso interactivo y gratuito de Ruby de Coddy te lleva paso a paso desde las variables y las cadenas hasta los bloques y las clases.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los temas más comunes (variables, cadenas, control de flujo) hasta los avanzados (bloques, procs, clases), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
