Ruby Academy · Aula

Casos de uso práticos

Analise dados estruturados.

Casos de uso práticos é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Por que a correspondência de padrões se destaca

A correspondência de padrões é mais útil ao lidar com dados estruturados: respostas de APIs, árvores de configuração e arquivos analisados. Ela substitui verificações aninhadas com if/dig por uma única expressão legível.

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

Como tratar sucesso e erro de uma API

Faça a correspondência com diferentes formatos de resposta em ramificações distintas, extraindo os campos corretos para cada um.

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' }))

Análise de argumentos de comando

Faça a correspondência entre uma lista de argumentos e os comandos para encaminhá-los de forma organizada.

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']))

Validação da estrutura de um registro

Use um padrão para verificar se um registro tem os campos e tipos obrigatórios antes de processá-lo.

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 }))

Desestruturação de configurações aninhadas

Extraia valores profundos da configuração em uma única correspondência, em vez de usar consultas encadeadas.

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

Uniões marcadas

Um padrão funcional comum: dados marcados por tipo e encaminhados com base nessa marca.

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 }))

Correspondência com desestruturação

Objetos personalizados podem participar da correspondência se definirem deconstruct (para padrões de lista). Struct faz isso automaticamente.

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

Correspondência com desestruturação de chaves

Defina deconstruct_keys para oferecer suporte a padrões de mapa. Struct também fornece esse recurso, permitindo correspondências nomeadas.

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

Classe com padrão

Combine um padrão de tipo com um padrão de mapa para corresponder a uma classe específica e aos seus 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

Sempre forneça um else quando a entrada puder não corresponder, transformando uma exceção em um tratamento adequado.

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

Juntando tudo

Um fluxo realista: analise JSON, corresponda à sua estrutura, valide com uma guarda e tome uma ação, tudo em uma única expressão organizada.

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

Verificação rápida

Qual método uma classe personalizada deve definir para oferecer suporte à correspondência de padrões de mapa, como in { x:, y: }?

Recapitulação: casos de uso práticos

Você aplicou a correspondência de padrões a problemas reais:

Encaminhamento de respostas de APIs e comandos
Validação da estrutura de registros com guardas
Desestruturação de configurações aninhadas e uniões marcadas
deconstruct / deconstruct_keys para objetos personalizados
Sempre adicione else para obter alternativas seguras

Você concluiu o curso de correspondência de padrões do Ruby.

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

Perguntas Frequentes

A aula “Casos de uso práticos” é grátis?

Sim — o texto completo de “Casos de uso práticos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Casos de uso práticos”?

Analise dados estruturados. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Casos de uso práticos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy