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

Para agregar un nuevo par a Hash lo hago:

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

¿Hay una forma similar de eliminar una clave de Hash?

Esto funciona:

{:a => 1, :b => 2}.reject! { |k| k == :a }   #=> {:b => 2}

pero esperaría tener algo como:

{:a => 1, :b => 2}.delete!(:a)   #=> {:b => 2}

Es importante que el valor de retorno sea el hash restante, por lo que podría hacer cosas como:

foo(my_hash.reject! { |k| k == my_key })

en una linea

Rails tiene una excepción / excepto! método que devuelve el hash con esas claves eliminadas. Si ya está utilizando Rails, no tiene sentido crear su propia versión de esto.

class Hash
  # Returns a hash that includes everything but the given keys.
  #   hash = { a: true, b: false, c: nil}
  #   hash.except(:c) # => { a: true, b: false}
  #   hash # => { a: true, b: false, c: nil}
  #
  # This is useful for limiting a set of parameters to everything but a few known toggles:
  #   @person.update(params[:person].except(:admin))
  def except(*keys)
    dup.except!(*keys)
  end

  # Replaces the hash without the given keys.
  #   hash = { a: true, b: false, c: nil}
  #   hash.except!(:c) # => { a: true, b: false}
  #   hash # => { a: true, b: false }
  def except!(*keys)
    keys.each { |key| delete(key) }
    self
  end
end

Oneliner liso rubí, solo funciona con rubí> 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 lo ha requerido active_support/core_ext/hash(que se requiere automáticamente en todas las aplicaciones de 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 utiliza un enfoque de lista negra, por lo que elimina todas las claves enumeradas como argumentos, mientras que slice utiliza un enfoque de lista blanca, por lo que elimina todas las claves que no figuran como argumentos. También existe la versión de explosión de esos métodos ( except!y slice!) que modifican el hash dado pero su valor de retorno es diferente, ambos devuelven un hash. Representa las claves eliminadas slice!y las claves que se guardan 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 solo usar:

hash.delete(key)

Hay muchas formas 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. Úselo slice!si desea eliminar las claves permanentemente; de ​​lo contrario, use simple slice.

   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 (puede aceptar solo 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 eliminará nada del hash original. Úselo except!si desea eliminar las claves permanentemente; de ​​lo contrario, use simple except.

   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} 

5. .compact=> Se utiliza para eliminar todos los nilvalores del hash. Úselo compact!si desea eliminar los nilvalores permanentemente; de ​​lo contrario, use simple compact.

   2.2.2 :119 > hash = {"one"=>1, "two"=>2, "three"=>3, "nothing"=>nil, "no_value"=>nil}
    => {"one"=>1, "two"=>2, "three"=>3, "nothing"=>nil, "no_value"=>nil} 
   2.2.2 :120 > hash.compact
    => {"one"=>1, "two"=>2, "three"=>3}

Resultados basados ​​en Ruby 2.2.2.

Si desea usar Ruby puro (sin Rails), no desea crear métodos de extensión (tal vez solo necesite esto en uno o dos lugares y no quiera contaminar el espacio de nombres con toneladas de métodos) y no quiera edite el hash en su lugar (es decir, usted es fanático de la programación funcional como yo), puede '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 devuelva una copia del hash con las claves eliminadas, ¡mientras que eliminar! modifica el hash mismo. Esto está de acuerdo con las convenciones de rubí. 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 facetsgema:

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

El hash original no cambia.

EDITAR: como dice Russel, las facetas tienen algunos problemas ocultos y no son completamente compatibles con API con ActiveSupport. Por otro lado, ActiveSupport no es tan completo como las facetas. Al final, usaría AS y dejaría los casos extremos en su código.

En lugar de parchear mono o incluir innecesariamente grandes bibliotecas, puede usar mejoras 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 función 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 puro rubí:

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

Ver Ruby on Rails: eliminar varias claves hash

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

Fue genial si eliminar devuelve el par de eliminación del hash. Estoy haciendo esto:

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

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

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

Múltiples formas de eliminar Key in Hash. puedes usar cualquier método desde abajo

hash = {a: 1, b: 2, c: 3}
hash.except!(:a) # Will remove *a* and return HASH
hash # Output :- {b: 2, c: 3}

hash = {a: 1, b: 2, c: 3}
hash.delete(:a) # will remove *a* and return 1 if *a* not present than return nil

Hay tantas maneras, puedes mirar Ruby doc de Hash aquí .

Gracias

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