ruby - into - ¿Cómo extraigo un sub hash de un hash?

hash.map ruby

Question

Tengo un hash:

h1 = {:a => :A, :b => :B, :c => :C, :d => :D}

¿Cuál es la mejor manera de extraer un sub hash como este?

h1.extract_subhash(:b, :d, :e, :f) # => {:b => :B, :d => :D}
h1 #=> {:a => :A, :c => :C}

Answer 1

Aquí hay una comparación de rendimiento rápido de los métodos sugeridos, #select parece ser el más rápido

k = 1_000_000
Benchmark.bmbm do |x|
x.report(''select'') { k.times { {a: 1, b: 2, c: 3}.select { |k, _v| [:a, :b].include?(k) } } }
x.report(''hash transpose'') { k.times { Hash[ [[:a, :b], {a: 1, b: 2, c: 3}.fetch_values(:a, :b)].transpose ] } }
x.report(''slice'') { k.times { {a: 1, b: 2, c: 3}.slice(:a, :b) } }
end
Rehearsal --------------------------------------------------
select 1.640000 0.010000 1.650000 ( 1.651426)
hash transpose 1.720000 0.010000 1.730000 ( 1.729950)
slice 1.740000 0.010000 1.750000 ( 1.748204)
----------------------------------------- total: 5.130000sec
user system total real
select 1.670000 0.010000 1.680000 ( 1.683415)
hash transpose 1.680000 0.010000 1.690000 ( 1.688110)
slice 1.800000 0.010000 1.810000 ( 1.816215)

El refinamiento se verá así:

module CoreExtensions
module Extractable
refine Hash do
def extract(*keys)
select { |k, _v| keys.include?(k) }
end
end
end
end

Y para usarlo:

using ::CoreExtensions::Extractable
{ a: 1, b: 2, c: 3 }.extract(:a, :b)

Answer 2

Aquí hay una solución funcional que puede ser útil si no está utilizando Ruby 2.5 y en el caso de que no quiera contaminar su clase Hash agregando un nuevo método:

slice_hash = -> keys, hash { hash.select { |k, _v| keys.include?(k) } }.curry

Luego puede aplicarlo incluso en hashes anidados:

my_hash = [{name: "Joe", age: 34}, {name: "Amy", age: 55}]
my_hash.map(&slice_hash.([:name]))
# => [{:name=>"Joe"}, {:name=>"Amy"}]

Answer 3

Este código inyecta la funcionalidad que está solicitando en la clase Hash:

class Hash
def extract_subhash! *keys
to_keep = self.keys.to_a - keys
to_delete = Hash[self.select{|k,v| !to_keep.include? k}]
self.delete_if {|k,v| !to_keep.include? k}
to_delete
end
end

y produce los resultados que proporcionó:

h1 = {:a => :A, :b => :B, :c => :C, :d => :D}
p h1.extract_subhash!(:b, :d, :e, :f) # => {b => :B, :d => :D}
p h1 #=> {:a => :A, :c => :C}

Nota: este método realmente devuelve las claves / valores extraídos.

Answer 4

Puede usar slice! (* Keys) que está disponible en las extensiones principales de ActiveSupport

initial_hash = {:a => 1, :b => 2, :c => 3, :d => 4}
extracted_slice = initial_hash.slice!(:a, :c)

initial_hash ahora sería

{:b => 2, :d =>4}

extraído_slide sería ahora

{:a => 1, :c =>3}

Puede ver slice.rb in ActiveSupport 3.1.3

Answer 5

Si desea específicamente que el método devuelva los elementos extraídos, h1 permanecerá igual:

h1 = {:a => :A, :b => :B, :c => :C, :d => :D}
h2 = h1.select {|key, value| [:b, :d, :e, :f].include?(key) } # => {:b=>:B, :d=>:D}
h1 = Hash[h1.to_a - h2.to_a] # => {:a=>:A, :c=>:C}

Y si quieres aplicar un parche a la clase Hash:

class Hash
def extract_subhash(*extract)
h2 = self.select{|key, value| extract.include?(key) }
self.delete_if {|key, value| extract.include?(key) }
h2
end
end

Si solo desea eliminar los elementos especificados del hash, es mucho más fácil utilizar delete_if .

h1 = {:a => :A, :b => :B, :c => :C, :d => :D}
h1.delete_if {|key, value| [:b, :d, :e, :f].include?(key) } # => {:a=>:A, :c=>:C}
h1 # => {:a=>:A, :c=>:C}

Answer 6

si usa rieles, puede ser conveniente usar Hash.except

h = {a:1, b:2}
h1 = h.except(:a) # {b:2}

Answer 7

Ruby 2.5 añadió Hash#slice :

h = { a: 100, b: 200, c: 300 }
h.slice(:a) #=> {:a=>100}
h.slice(:b, :c, :d) #=> {:b=>200, :c=>300}

Answer 8

ActiveSupport , al menos desde 2.3.8, proporciona cuatro métodos convenientes: #slice , #except y sus contrapartes destructivas: #slice! y #except! . Se mencionaron en otras respuestas, pero para resumirlas en un solo lugar:

x = {a: 1, b: 2, c: 3, d: 4}
# => {:a=>1, :b=>2, :c=>3, :d=>4}
x.slice(:a, :b)
# => {:a=>1, :b=>2}
x
# => {:a=>1, :b=>2, :c=>3, :d=>4}
x.except(:a, :b)
# => {:c=>3, :d=>4}
x
# => {:a=>1, :b=>2, :c=>3, :d=>4}

Tenga en cuenta los valores de retorno de los métodos de explosión. No solo adaptarán el hash existente, sino que también devolverán las entradas eliminadas (no guardadas). The Hash#except! se adapta mejor al ejemplo dado en la pregunta:

x = {a: 1, b: 2, c: 3, d: 4}
# => {:a=>1, :b=>2, :c=>3, :d=>4}
x.except!(:c, :d)
# => {:a=>1, :b=>2}
x
# => {:a=>1, :b=>2}

ActiveSupport no requiere raíles completos, es bastante liviano. De hecho, muchas gemas que no son de rieles dependen de ello, así que lo más probable es que ya lo tengas en Gemfile.lock. No es necesario extender la clase Hash por su cuenta.

Answer 9

Si usa rieles , Hash#slice es el camino a seguir.

{:a => :A, :b => :B, :c => :C, :d => :D}.slice(:a, :c)
# => {:a => :A, :c => :C}

Si no utiliza los rieles , Hash # values_at devolverá los valores en el mismo orden en que los solicitó para que pueda hacer esto:

def slice(hash, *keys)
Hash[ [keys, hash.values_at(*keys)].transpose]
end
def except(hash, *keys)
desired_keys = hash.keys - keys
Hash[ [desired_keys, hash.values_at(*desired_keys)].transpose]
end

ex:

slice({foo: ''bar'', ''bar'' => ''foo'', 2 => ''two''}, ''bar'', 2)
# => {''bar'' => ''foo'', 2 => ''two''}
except({foo: ''bar'', ''bar'' => ''foo'', 2 => ''two''}, ''bar'', 2)
# => {:foo => ''bar''}

Explicación:

Fuera de {:a => 1, :b => 2, :c => 3} queremos {:a => 1, :b => 2}

hash = {:a => 1, :b => 2, :c => 3}
keys = [:a, :b]
values = hash.values_at(*keys) #=> [1, 2]
transposed_matrix =[keys, values].transpose #=> [[:a, 1], [:b, 2]]
Hash[transposed_matrix] #=> {:a => 1, :b => 2}

Si siente que el parche de monos es el camino a seguir, lo siguiente es lo que quiere:

module MyExtension
module Hash
def slice(*keys)
::Hash[[keys, self.values_at(*keys)].transpose]
end
def except(*keys)
desired_keys = self.keys - keys
::Hash[[desired_keys, self.values_at(*desired_keys)].transpose]
end
end
end
Hash.include MyExtension::Hash

Answer 10

class Hash
def extract(*keys)
key_index = Hash[keys.map{ |k| [k, true] }] # depends on the size of keys
partition{ |k, v| key_index.has_key?(k) }.map{ |group| Hash[group] }
end
end
h1 = {:a => :A, :b => :B, :c => :C, :d => :D}
h2, h1 = h1.extract(:b, :d, :e, :f)

Answer 11

h1 = {:a => :A, :b => :B, :c => :C, :d => :D}
keys = [:b, :d, :e, :f]
h2 = (h1.keys & keys).each_with_object({}) { |k,h| h.update(k=>h1.delete(k)) }
#=> {:b => :B, :d => :D}
h1
#=> {:a => :A, :c => :C}

Answer 12

module HashExtensions
def subhash(*keys)
keys = keys.select { |k| key?(k) }
Hash[keys.zip(values_at(*keys))]
end
end
Hash.send(:include, HashExtensions)
{:a => :A, :b => :B, :c => :C, :d => :D}.subhash(:a) # => {:a => :A}