Ruby Academy · Lezione

Casi d'uso pratici

Analizzare dati strutturati

Casi d'uso pratici è una lezione Ruby Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Perché il pattern matching è efficace

Il pattern matching dà il meglio di sé nella gestione di dati strutturati: risposte API, alberi di configurazione e file analizzati. Sostituisce i controlli annidati if/dig con un'unica espressione leggibile.

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

Gestire il successo e gli errori delle API

Faccia corrispondere forme diverse delle risposte in rami distinti, estraendo i campi appropriati per ciascuna.

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

Analizzare gli argomenti dei comandi

Faccia corrispondere un array di argomenti per distribuire i comandi in modo ordinato.

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

Convalidare la struttura di un record

Utilizzi un pattern per verificare che un record abbia i campi e i tipi richiesti prima di elaborarlo.

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

Destrutturare una configurazione annidata

Estragga i valori profondi della configurazione con un'unica corrispondenza invece di usare ricerche concatenate.

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

Unioni con tag

Un pattern funzionale comune: dati contrassegnati dal tipo e instradati in base al relativo tag.

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

Corrispondenza con deconstruct

Gli oggetti personalizzati possono essere utilizzati nei pattern se definiscono deconstruct (per i pattern per array). Struct lo fa automaticamente.

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

Corrispondenza con deconstruct_keys

Definisca deconstruct_keys per supportare i pattern per hash. Anche Struct lo fornisce, abilitando la corrispondenza tramite nomi.

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

Classe con pattern

Combini un pattern di tipo con un pattern per hash per far corrispondere una classe specifica e i relativi campi.

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

Fallback sicuri

Fornisca sempre un else quando l'input potrebbe non corrispondere, trasformando un'eccezione in una gestione corretta.

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

Mettere tutto insieme

Un flusso realistico: analizzi JSON, ne verifichi la struttura, lo convalidi con una guardia e agisca, tutto in un'unica espressione ordinata.

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 rapida

Quale metodo deve definire una classe personalizzata per supportare la corrispondenza con un pattern per hash come in { x:, y: }?

Riepilogo: casi d'uso pratici

Ha applicato il pattern matching a problemi reali:

Distribuzione delle risposte API e dei comandi
Convalida della struttura dei record con le guardie
Destrutturazione di configurazioni annidate e unioni con tag
deconstruct / deconstruct_keys per gli oggetti personalizzati
Aggiunga sempre un else per gestire i casi non corrispondenti in modo sicuro

Ha completato il corso Ruby Pattern Matching.

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

Domande Frequenti

La lezione «Casi d'uso pratici» è gratuita?

Sì — il testo completo di «Casi d'uso pratici» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Casi d'uso pratici»?

Analizzare dati strutturati Eserciti Ruby Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Casi d'uso pratici»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Ruby Academy?

Sì. Ogni lezione Ruby Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Ruby Academy