Ruby: ¿La Forma más Fácil de Filtrar las Claves Hash?

En Ruby, el Hash#select es una opción correcta. Si trabajas con Rails, puedes usar Hash # slice y Hash#slice!. por ejemplo (rails 3.2.13)

h1 = {:a => 1, :b => 2, :c => 3, :d => 4}

h1.slice(:a, :b)         # return {:a=>1, :b=>2}, but h1 is not changed

h2 = h1.slice!(:a, :b)   # h1 = {:a=>1, :b=>2}, h2 = {:c => 3, :d => 4}

La forma más fácil es incluir el gem 'activesupport' (o gem 'active_support').

Entonces, en tu clase solo necesitas

require 'active_support/core_ext/hash/slice'

Y llamar

params.slice(:choice1, :choice2, :choice3) # => {:choice1=>"Oh look, another one", :choice2=>"Even more strings", :choice3=>"But wait"}

Creo que no vale la pena declarar otras funciones que pueden tener errores, y es mejor usar un método que se ha ajustado durante los últimos años.

La forma más fácil es incluir la gema 'activesupport' (o gema 'active_support').

params.slice(:choice1, :choice2, :choice3)

Esta es una línea para resolver la pregunta original completa:

params.select { |k,_| k[/choice/]}.values.join('\t')

Pero la mayoría de las soluciones anteriores están resolviendo un caso en el que necesita conocer las claves con anticipación, usando slice o regexp simple.

Aquí hay otro enfoque que funciona para casos de uso simples y más complejos, que se puede intercambiar en tiempo de ejecución

data = {}
matcher = ->(key,value) { COMPLEX LOGIC HERE }
data.select(&matcher)

Ahora no solo esto permite una lógica más compleja sobre la coincidencia de las claves o los valores, sino que también es más fácil de probar, y puede intercambiar la coincidencia lógica en tiempo de ejecución.

Ex para resolver el problema original:

def some_method(hash, matcher) 
  hash.select(&matcher).values.join('\t')
end

params = { :irrelevant => "A String",
           :choice1 => "Oh look, another one",
           :choice2 => "Even more strings",
           :choice3 => "But wait",
           :irrelevant2 => "The last string" }

some_method(params, ->(k,_) { k[/choice/]}) # => "Oh look, another one\\tEven more strings\\tBut wait"
some_method(params, ->(_,v) { v[/string/]}) # => "Even more strings\\tThe last string"

Si trabajas con rails y tienes las claves en una lista separada, puedes usar la notación *:

keys = [:foo, :bar]
hash1 = {foo: 1, bar:2, baz: 3}
hash2 = hash1.slice(*keys)
=> {foo: 1, bar:2}

Como se indica en otras respuestas, también puede usar slice! para modificar el hash en su lugar (y devolver la clave/los valores borrados).

Pon esto en un inicializador

class Hash
  def filter(*args)
    return nil if args.try(:empty?)
    if args.size == 1
      args[0] = args[0].to_s if args[0].is_a?(Symbol)
      self.select {|key| key.to_s.match(args.first) }
    else
      self.select {|key| args.include?(key)}
    end
  end
end

Entonces puedes hacer

{a: "1", b: "b", c: "c", d: "d"}.filter(:a, :b) # =>  {a: "1", b: "b"}

O

{a: "1", b: "b", c: "c", d: "d"}.filter(/^a/)  # =>  {a: "1"}

Con Hash::select:

params = params.select { |key, value| /^choice\d+$/.match(key.to_s) }

Si quieres el hash restante:

params.delete_if {|k, v| ! k.match(/choice[0-9]+/)}

O si solo quieres las claves:

params.keys.delete_if {|k| ! k.match(/choice[0-9]+/)}

params.select{ |k,v| k =~ /choice\d/ }.map{ |k,v| v}.join("\t")

En cuanto a la pregunta de bonificación:

1. Si tiene salida de #select método como este (lista de matrices de 2 elementos):

   [[:choice1, "Oh look, another one"], [:choice2, "Even more strings"], [:choice3, "But wait"]]
   

   Entonces simplemente toma este resultado y ejecuta:

   filtered_params.join("\t")
   # or if you want only values instead of pairs key-value
   filtered_params.map(&:last).join("\t")
   

2. Si tienes salida de #delete_if método como este (hash):

   {:choice1=>"Oh look, another one", :choice2=>"Even more strings", :choice3=>"But wait"}
   

   Entonces:

   filtered_params.to_a.join("\t")
   # or
   filtered_params.values.join("\t")
   

params = { :irrelevant => "A String",
           :choice1 => "Oh look, another one",
           :choice2 => "Even more strings",
           :choice3 => "But wait",
           :irrelevant2 => "The last string" }

choices = params.select { |key, value| key.to_s[/^choice\d+/] }
#=> {:choice1=>"Oh look, another one", :choice2=>"Even more strings", :choice3=>"But wait"}