Ruby Academy · Lección

Cuellos de botella comunes

Acelere el código Ruby

Cuellos de botella comunes es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

Reconocer cuellos de botella

La mayoría de las ralentizaciones en Ruby provienen de unos pocos patrones recurrentes. Conocerlos le permite corregir el código rápidamente.

Una estructura de datos inadecuada para la tarea
Trabajo repetido que podría almacenarse en caché
Consultas N+1 y bucles anidados

En esta lección se tratan los problemas más comunes.

puts 'Speeding up Ruby starts with knowing the usual suspects'

Array#include? frente a Set

Comprobar la pertenencia con Array#include? es O(n). Un Set o un hash ofrece búsquedas O(1).

Para comprobaciones de pertenencia repetidas, cree un Set una sola vez
La mejora de velocidad es enorme en colecciones grandes

require 'set'

allowed = Set.new(['a', 'b', 'c'])
puts allowed.include?('b')
puts allowed.include?('z')

Bucles anidados (O(n al cuadrado))

Comparar todos los pares de elementos tiene complejidad cuadrática y el coste se dispara a medida que aumenta el tamaño.

Sustituya los bucles internos por una búsqueda en un hash
Transforma O(n al cuadrado) en O(n)

a = [1, 2, 3, 4]
b = [3, 4, 5]
set_b = b.to_set rescue require('set') || b.to_set
common = a.select { |x| set_b.include?(x) }
puts common.inspect

El patrón N+1

Obtener datos relacionados dentro de un bucle provoca N+1 operaciones.

Una consulta para la lista y después una por cada elemento
Agrupe las búsquedas mediante una única obtención agrupada

# Bad: lookup inside loop
orders = [1, 2, 3]
prices = { 1 => 10, 2 => 20, 3 => 30 }
# Good: one preloaded hash, O(1) per item
total = orders.sum { |id| prices[id] }
puts total

Memoización

Recalcular el mismo valor costoso desperdicia tiempo. Memorícelo con ||=.

Almacene el resultado en caché después del primer cálculo
Las llamadas posteriores devuelven el resultado al instante

class Report
  def total
    @total ||= begin
      puts 'computing...'
      (1..1000).sum
    end
  end
end

r = Report.new
puts r.total
puts r.total

Elegir el método adecuado

Algunos métodos de Enumerable son mucho más rápidos que las cadenas de llamadas.

sum supera a inject(:+)
any? se detiene en cuanto encuentra un resultado, a diferencia de select.empty?
find se detiene en la primera coincidencia

nums = (1..1_000_000)
puts nums.any? { |n| n > 5 }
puts nums.find { |n| n > 5 }

Evitar ordenar repetidamente

Ordenar dentro de un bucle o hacerlo repetidamente es costoso. Ordene una vez y reutilice el resultado.

Ordenar tiene una complejidad de O(n log n)
Almacene en caché el resultado ordenado si los datos son estables

data = [5, 2, 8, 1, 9]
sorted = data.sort
puts sorted.first
puts sorted.last

Agrupación con hash

group_by y tally agregan los datos en una sola pasada en lugar de realizar búsquedas repetidas.

tally cuenta las apariciones de forma eficiente
Evita los bucles manuales de conteo

words = ['a', 'b', 'a', 'c', 'b', 'a']
puts words.tally.inspect

Coste de construir cadenas

Usar join es más rápido que concatenar repetidamente cuando se trabaja con colecciones.

Construya un array y después use join una sola vez
Evita muchas cadenas intermedias

parts = (1..5).map { |i| "item#{i}" }
puts parts.join(', ')

Compilación de expresiones regulares

Definir un literal de expresión regular dentro de un bucle crítico hace que se vuelva a compilar implícitamente. Extráigalo a una constante.

Compile una vez y haga muchas coincidencias
Use match? cuando solo necesite un valor booleano

EMAIL = /\A[^@\s]+@[^@\s]+\z/

inputs = ['a@b.com', 'nope', 'x@y.org']
valid = inputs.select { |s| EMAIL.match?(s) }
puts valid.inspect

Ejecución diferida del trabajo

No calcule lo que quizá nunca utilice. Difiera el cálculo mediante evaluación perezosa o condiciones de protección.

Devuelva el resultado pronto cuando sea posible
Calcule los valores costosos solo cuando se soliciten

def describe(items)
  return 'empty' if items.empty?
  "#{items.size} items, first is #{items.first}"
end

puts describe([])
puts describe([10, 20])

Comprobación rápida

Compruebe sus conocimientos sobre cuellos de botella.

Resumen

Ha aprendido a corregir los cuellos de botella comunes:

Use Set o un hash para comprobar la pertenencia rápidamente en lugar de include?
Elimine los bucles anidados y los patrones N+1 con hashes precargados
Memorice los cálculos costosos con ||=
Elija métodos eficientes (sum, any?, tally) y extraiga las expresiones regulares del bucle
Difiera u omita el trabajo que quizá nunca necesite

Mida siempre antes y después para confirmar la mejora.

Preguntas frecuentes

¿La lección «Cuellos de botella comunes» es gratis?

Sí — el texto completo de «Cuellos de botella comunes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cuellos de botella comunes»?

Acelere el código Ruby Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Cuellos de botella comunes»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Ruby Academy