Ruby Academy · Lección

Casos de uso prácticos

Analice datos estructurados

Casos de uso prácticos 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.

Por qué destaca la coincidencia de patrones

La coincidencia de patrones resulta especialmente útil al trabajar con datos estructurados: respuestas de API, árboles de configuración y archivos analizados. Sustituye las comprobaciones anidadas con if/dig por una sola expresión legible.

require 'json'
resp = JSON.parse('{"ok":true,"data":42}', symbolize_names: true)
case resp
in { ok: true, data: }
  puts(data)
end

Gestionar éxitos y errores de una API

Haga coincidir distintas formas de respuesta en ramas separadas y extraiga los campos adecuados para cada una.

def handle(resp)
  case resp
  in { status: 'ok', result: }
    "got #{result}"
  in { status: 'error', message: }
    "error: #{message}"
  end
end
puts(handle({ status: 'error', message: 'bad input' }))

Analizar argumentos de comandos

Haga coincidir un array de argumentos para distribuir los comandos con claridad.

def run(args)
  case args
  in ['add', a, b]
    a.to_i + b.to_i
  in ['echo', *rest]
    rest.join(' ')
  end
end
puts(run(['add', '3', '4']))
puts(run(['echo', 'hi', 'there']))

Validar la forma de un registro

Use un patrón para comprobar que un registro tiene los campos y tipos necesarios antes de procesarlo.

def valid?(rec)
  case rec
  in { name: String, age: Integer => a } if a >= 0
    true
  else
    false
  end
end
puts(valid?({ name: 'Ada', age: 36 }))
puts(valid?({ name: 'X', age: -1 }))

Desestructurar una configuración anidada

Extraiga valores profundos de la configuración en una sola coincidencia, en lugar de encadenar búsquedas.

cfg = { server: { host: 'localhost', port: 8081 } }
case cfg
in { server: { host:, port: } }
  puts("#{host}:#{port}")
end

Uniones etiquetadas

Un patrón funcional habitual: datos etiquetados por tipo y distribuidos según su etiqueta.

def area(shape)
  case shape
  in { type: 'circle', r: }
    (3.14 * r * r).round(2)
  in { type: 'rect', w:, h: }
    w * h
  end
end
puts(area({ type: 'rect', w: 3, h: 4 }))

Hacer coincidir con deconstruct

Los objetos personalizados pueden participar en coincidencias si definen deconstruct (para patrones de array). Struct lo hace automáticamente.

Point = Struct.new(:x, :y)
case Point.new(1, 2)
in [x, y]
  puts("#{x},#{y}")
end

Hacer coincidir con deconstruct_keys

Defina deconstruct_keys para admitir patrones de hash. Struct también proporciona este método, lo que permite hacer coincidir por nombre.

Point = Struct.new(:x, :y)
case Point.new(3, 4)
in { x:, y: }
  puts("x=#{x} y=#{y}")
end

Clase con patrón

Combine un patrón de tipo con un patrón de hash para hacer coincidir una clase específica y sus campos.

User = Struct.new(:name, :admin, keyword_init: true)
case User.new(name: 'Ada', admin: true)
in User(admin: true, name:)
  puts("#{name} is an admin")
end

Alternativas seguras

Proporcione siempre un else cuando la entrada pueda no coincidir, convirtiendo una excepción en una gestión controlada.

def parse(data)
  case data
  in { id: Integer => id }
    "id #{id}"
  else
    'unrecognized'
  end
end
puts(parse({ name: 'x' }))

Integrarlo todo

Un flujo realista: analizar JSON, hacer coincidir su estructura, validarla con una guarda y actuar, todo en una expresión ordenada.

require 'json'
event = JSON.parse('{"kind":"purchase","amount":150}', symbolize_names: true)
case event
in { kind: 'purchase', amount: Integer => amt } if amt > 100
  puts("big purchase: #{amt}")
in { kind: 'purchase', amount: }
  puts("purchase: #{amount}")
end

Comprobación rápida

¿Qué método debe definir una clase personalizada para admitir la coincidencia de patrones de hash como in { x:, y: }?

Repaso: casos de uso prácticos

Ha aplicado la coincidencia de patrones a problemas reales:

Distribuir respuestas de API y comandos
Validar la forma de los registros con guardas
Desestructurar configuraciones anidadas y uniones etiquetadas
deconstruct / deconstruct_keys para objetos personalizados
Añadir siempre un else como alternativa segura

Ha completado el curso de coincidencia de patrones de Ruby.

case { type: 'circle', r: 2 }
in { type: 'circle', r: } then puts(3.14 * r * r)
end

Preguntas frecuentes

¿La lección «Casos de uso prácticos» es gratis?

Sí — el texto completo de «Casos de uso prácticos» 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 «Casos de uso prácticos»?

Analice datos estructurados 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 «Casos de uso prácticos»?

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