Ruby Pattern Matching: Stop met Geneste if/elsif Ketens

Ruby’s case/when is al sinds het begin de standaard voor conditionele logica. Maar sinds Ruby 3.0 is pattern matching met case/in stilletjes een van de krachtigste features geworden die de meeste Rubyisten nog steeds niet gebruiken.

Als je geneste conditionals schrijft om hashes te destructureren, array-structuren te controleren of API-responses te valideren, vervangt pattern matching dat allemaal door iets dat drastisch leesbaarder is.

De Basis: case/in vs case/when

Traditioneel Ruby:

case response
when Hash
  if response[:status] == "ok" && response[:data].is_a?(Array)
    process(response[:data])
  end
end

Met pattern matching:

case response
in { status: "ok", data: Array => items }
  process(items)
end

Hetzelfde resultaat, de helft van de ruis. Het in keyword destructureert en bindt in één stap.

Geneste Structuren Destructureren

Pattern matching schittert bij diep geneste data — precies het soort structuren dat API’s je toesturen.

case api_response
in { user: { name: String => name, roles: [*, "admin", *] } }
  grant_admin_access(name)
in { user: { name: String => name, roles: Array } }
  grant_standard_access(name)
in { error: { code: Integer => code, message: String => msg } }
  handle_error(code, msg)
end

Het [*, "admin", *] patroon matcht elke array die "admin" op willekeurige positie bevat. Probeer dat maar eens netjes uit te drukken met if/elsif.

Guard Clauses met if

Patronen ondersteunen inline guards:

case order
in { total: Float | Integer => amount } if amount > 1000
  apply_bulk_discount(order)
in { total: Float | Integer => amount } if amount > 0
  process_standard(order)
in { total: 0 }
  handle_zero_order(order)
end

Het Find Pattern

Ruby 3.0 introduceerde het find-patroon voor het matchen van elementen binnen arrays:

case users
in [*, { name: "Roger", role: } , *]
  puts "Roger gevonden met rol: #{role}"
end

Dit doorzoekt de array en bindt de eerste match. Geen find of detect nodig.

Pin Operator voor Dynamische Waarden

Wanneer je moet matchen tegen een variabele in plaats van er een te binden, gebruik je de pin operator ^:

expected_status = "active"

case account
in { status: ^expected_status, balance: Integer => bal }
  puts "Actief account met saldo: #{bal}"
end

Zonder ^ zou expected_status als een nieuwe variabele-binding worden behandeld in plaats van een vergelijking.

Pattern Matching in Method-Argumenten (Ruby 3.1+)

Sinds Ruby 3.1 kun je pattern matching direct in methode-signatures gebruiken voor validatie:

def process_event(event)
  event => { type: String => type, payload: Hash => data }
  # Als het patroon niet matcht, gooit het NoMatchingPatternError

  case type
  in "user.created"
    create_user(data)
  in "user.deleted"
    remove_user(data)
  end
end

De standalone => operator (rightward assignment) destructureert en gooit een fout als het patroon niet matcht — een beknopt alternatief voor handmatige validatie.

Praktijkvoorbeeld: Webhook Payloads Parsen

Een voor/na van een Stripe webhook handler:

Vóór:

def handle_webhook(payload)
  return unless payload.is_a?(Hash)
  return unless payload[:type].is_a?(String)

  case payload[:type]
  when "invoice.paid"
    return unless payload[:data].is_a?(Hash)
    return unless payload[:data][:object].is_a?(Hash)
    amount = payload.dig(:data, :object, :amount_paid)
    customer = payload.dig(:data, :object, :customer)
    return unless amount && customer
    record_payment(customer, amount)
  when "customer.subscription.deleted"
    customer = payload.dig(:data, :object, :customer)
    return unless customer
    cancel_subscription(customer)
  end
end

Na:

def handle_webhook(payload)
  case payload
  in { type: "invoice.paid",
       data: { object: { amount_paid: Integer => amount,
                          customer: String => customer } } }
    record_payment(customer, amount)
  in { type: "customer.subscription.deleted",
       data: { object: { customer: String => customer } } }
    cancel_subscription(customer)
  else
    Rails.logger.debug("Onverwerkte webhook: #{payload[:type]}")
  end
end

Wanneer je pattern matching combineert met gestructureerde logging, worden onverwerkte webhook-types automatisch vastgelegd in je logs in plaats van er stilletjes doorheen te glippen.

De pattern matching-versie is korter, zelf-documenterend, en het is onmogelijk om een nil-check te vergeten — als de structuur niet matcht, wordt het patroon simpelweg niet uitgevoerd.

Prestatie-overwegingen

Pattern matching is niet gratis. Voor hot paths die miljoenen iteraties verwerken, is een directe hash-lookup sneller. Maar voor request-afhandeling, webhook-verwerking en configuratie-parsing — de plekken waar je daadwerkelijk verstrikte conditionals schrijft — is de overhead verwaarloosbaar en de duidelijkheidswinst enorm.

Wanneer Gebruik Je Het?

Gebruik pattern matching wanneer:

• Je API-responses of webhook payloads destructureert
• Je complexe datastructuren valideert
• Je ketens van dig + nil-checks vervangt
• Je switcht op geneste structuur, niet alleen type

Blijf bij case/when wanneer:

• Je eenvoudige waarden of typen matcht
• Prestatie kritiek is (tight loops)
• Je team de syntax nog niet kent (introduceer het geleidelijk)

Aan de Slag

Als je Ruby 3.0+ draait, heb je het al. Geen gems nodig. Begin met het vervangen van één lelijke conditional-keten in je codebase. Zodra je het verschil ziet, ga je niet meer terug.

Pattern matching is geen syntactische suiker — het is een andere manier van denken over dataflow. En in een taal die gebouwd is rond developer-geluk past dat precies. Het werkt bijzonder goed in background job handlers waar je verschillende event-types naar verschillende verwerkingspaden routeert.

Veelgestelde Vragen

Werkt pattern matching met ActiveRecord-modellen?

Niet direct — pattern matching werkt met hashes, arrays en objecten die deconstruct of deconstruct_keys implementeren. Je kunt matchen tegen model.attributes (dat een hash retourneert) of deconstruct_keys implementeren op je modellen. In de praktijk is pattern matching het nuttigst voor API-responses, params-hashes en service object-resultaten in plaats van ActiveRecord-objecten.

Is Ruby pattern matching langzamer dan if/elsif ketens?

Voor typische use cases zoals request-afhandeling of webhook-verwerking is het verschil verwaarloosbaar. Pattern matching is iets langzamer dan een directe hash-lookup in tight loops die miljoenen iteraties verwerken, maar voor code die op request-schaal draait, is leesbaarheid belangrijker dan nanoseconden. Benchmark je specifieke geval als performance kritiek is.

Wat gebeurt er als geen enkel patroon matcht?

Als geen in branch matcht en er geen else clause is, gooit Ruby een NoMatchingPatternError. Dit is eigenlijk een feature — het dwingt je om alle gevallen expliciet af te handelen. Voeg een else branch toe om onbekende gevallen netjes af te handelen, of laat het raisen als een ongematchd patroon een echte fout in je data vertegenwoordigt.