¿Cómo eliminar una clave de Hash y obtener el hash restante en Ruby/Rails?

Oneliner plain ruby, solo funciona con ruby > 1.9.x:

1.9.3p0 :002 > h = {:a => 1, :b => 2}
 => {:a=>1, :b=>2} 
1.9.3p0 :003 > h.tap { |hs| hs.delete(:a) }
 => {:b=>2} 

El método Tap siempre devuelve el objeto sobre el que se invoca...

De lo contrario, si ha requerido active_support/core_ext/hash (que se requiere automáticamente en cada aplicación Rails), puede usar uno de los siguientes métodos según sus necesidades:

➜  ~  irb
1.9.3p125 :001 > require 'active_support/core_ext/hash' => true 
1.9.3p125 :002 > h = {:a => 1, :b => 2, :c => 3}
 => {:a=>1, :b=>2, :c=>3} 
1.9.3p125 :003 > h.except(:a)
 => {:b=>2, :c=>3} 
1.9.3p125 :004 > h.slice(:a)
 => {:a=>1} 

Excepto que usa un enfoque de lista negra, por lo que elimina todas las claves listadas como args, mientras que slice usa un enfoque de lista blanca, por lo que elimina todas las claves que no aparecen como argumentos. También existe la versión bang de esos métodos (except! y slice!) que modifican el hash dado, pero su valor de retorno es diferente. Representa las claves eliminadas para slice! y las claves que se mantienen para except!:

1.9.3p125 :011 > {:a => 1, :b => 2, :c => 3}.except!(:a)
 => {:b=>2, :c=>3} 
1.9.3p125 :012 > {:a => 1, :b => 2, :c => 3}.slice!(:a)
 => {:b=>2, :c=>3} 

¿Por qué no usar:

hash.delete(key)

Hay muchas maneras de eliminar una clave de un hash y obtener el hash restante en Ruby.

1. .slice => Devolverá las claves seleccionadas y no las eliminará del hash original

   2.2.2 :074 > hash = {"one"=>1, "two"=>2, "three"=>3}
    => {"one"=>1, "two"=>2, "three"=>3} 
   2.2.2 :075 > hash.slice("one","two")
    => {"one"=>1, "two"=>2} 
   2.2.2 :076 > hash
    => {"one"=>1, "two"=>2, "three"=>3} 
   

2. .delete => Eliminará las claves seleccionadas del hash original (solo puede aceptar una clave y no más de una)

   2.2.2 :094 > hash = {"one"=>1, "two"=>2, "three"=>3}
    => {"one"=>1, "two"=>2, "three"=>3} 
   2.2.2 :095 > hash.delete("one")
    => 1 
   2.2.2 :096 > hash
    => {"two"=>2, "three"=>3} 
   

3. .except => Devolverá las claves restantes pero no borrará nada del original hash

   2.2.2 :097 > hash = {"one"=>1, "two"=>2, "three"=>3}
    => {"one"=>1, "two"=>2, "three"=>3} 
   2.2.2 :098 > hash.except("one","two")
    => {"three"=>3} 
   2.2.2 :099 > hash
    => {"one"=>1, "two"=>2, "three"=>3}         
   

4. .delete_if => En caso de que necesite eliminar una clave basada en un valor. Obviamente, eliminará las claves coincidentes del hash original

   2.2.2 :115 > hash = {"one"=>1, "two"=>2, "three"=>3, "one_again"=>1}
    => {"one"=>1, "two"=>2, "three"=>3, "one_again"=>1} 
   2.2.2 :116 > value = 1
    => 1 
   2.2.2 :117 > hash.delete_if { |k,v| v == value }
    => {"two"=>2, "three"=>3} 
   2.2.2 :118 > hash
    => {"two"=>2, "three"=>3} 
   

Resultados basados en Ruby 2.2.2.

Si quieres usar pure Ruby (sin Rails), no quieres crear métodos de extensión (tal vez necesitas esto solo en uno o dos lugares y no quieres contaminar el espacio de nombres con toneladas de métodos) y no quieres editar hash en su lugar (es decir, eres fan de la programación funcional como yo), puedes 'seleccionar':

>> x = {:a => 1, :b => 2, :c => 3}
=> {:a=>1, :b=>2, :c=>3}
>> x.select{|x| x != :a}
=> {:b=>2, :c=>3}
>> x.select{|x| ![:a, :b].include?(x)}
=> {:c=>3}
>> x
=> {:a=>1, :b=>2, :c=>3}

#in lib/core_extensions.rb
class Hash
  #pass single or array of keys, which will be removed, returning the remaining hash
  def remove!(*keys)
    keys.each{|key| self.delete(key) }
    self
  end

  #non-destructive version
  def remove(*keys)
    self.dup.remove!(*keys)
  end
end

#in config/initializers/app_environment.rb (or anywhere in config/initializers)
require 'core_extensions'

He configurado esto para que .remove devuelve una copia del hash con las claves eliminadas, mientras que remove! modifica el hash en sí. Esto está en consonancia con las convenciones de ruby. por ejemplo, desde la consola

>> hash = {:a => 1, :b => 2}
=> {:b=>2, :a=>1}
>> hash.remove(:a)
=> {:b=>2}
>> hash
=> {:b=>2, :a=>1}
>> hash.remove!(:a)
=> {:b=>2}
>> hash
=> {:b=>2}
>> hash.remove!(:a, :b)
=> {}

Puedes usar except! desde la gema facets:

>> require 'facets' # or require 'facets/hash/except'
=> true
>> {:a => 1, :b => 2}.except(:a)
=> {:b=>2}

El hash original no cambia.

EDIT: como dice Russel, facets tiene algunos problemas ocultos y no es completamente compatible con la API de ActiveSupport. Por otro lado, ActiveSupport no es tan completo como facets. Al final, usaría COMO y dejaría que los casos extremos en su código.

En lugar de aplicar parches monkey o incluir innecesariamente bibliotecas grandes, puede usar refinamientos si está utilizando Ruby 2:

module HashExtensions
  refine Hash do
    def except!(*candidates)
      candidates.each { |candidate| delete(candidate) }
      self
    end

    def except(*candidates)
      dup.remove!(candidates)
    end
  end
end

Puede usar esta característica sin afectar otras partes de su programa, o tener que incluir grandes bibliotecas externas.

class FabulousCode
  using HashExtensions

  def incredible_stuff
    delightful_hash.except(:not_fabulous_key)
  end
end

En Rubí puro:

{:a => 1, :b => 2}.tap{|x| x.delete(:a)}   # => {:b=>2}

Ver Ruby on Rails: Eliminar múltiples claves hash

hash.delete_if{ |k,| keys_to_delete.include? k }

Esta es una forma de una línea para hacerlo, pero no es muy legible. Recomiendo usar dos líneas en su lugar.

use_remaining_hash_for_something(Proc.new { hash.delete(:key); hash }.call)

Fue genial si delete devuelve el par delete del hash. Estoy haciendo esto:

hash = {a: 1, b: 2, c: 3}
{b: hash.delete(:b)} # => {:b=>2}
hash  # => {:a=>1, :c=>3} 

Esto también funcionaría: hash[hey] = nil