如何从哈希中提取子哈希？

Question

我有一个哈希：

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

提取这样的子哈希的最佳方法是什么？

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

Answer 1

ActiveSupport

，至少从 2.3.8 开始，提供了四种方便的方法：

#slice

、

#except

及其破坏性的对应方法：

#slice!

和

#except!

。其他答案中提到了它们，但将它们总结在一个地方：

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}

注意 bang 方法的返回值。他们不仅会定制现有的哈希值，还会返回已删除（未保留）的条目。

Hash#except!

最适合问题中给出的示例：

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

不需要整个Rails，非常轻量级。事实上，很多非 Rails gem 都依赖于它，所以很可能您已经在 Gemfile.lock 中拥有它了。无需自行扩展 Hash 类。

Answer 2

如果您特别希望该方法返回提取的元素但 h1 保持不变：

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}

如果你想将其修补到 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

如果您只想从哈希中删除指定的元素，使用 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 3

Ruby 2.5添加了Hash#slice：

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

Answer 4

如果您使用rails，则Hash#slice是正确的选择。

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

如果您不使用rails，Hash#values_at 将按照您询问的顺序返回值，因此您可以这样做：

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

例如：

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

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

说明：

出于

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

我们想要

{: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}

如果你觉得猴子补丁是可行的方法，那么以下就是你想要的：

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 5

您可以使用 ActiveSupport 核心扩展中提供的 slice!(*keys)

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

extracted_slice = initial_hash.slice!(:a, :c)

initial_hash 现在是

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

extracted_slide 现在是

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

你可以看看

slice.rb in ActiveSupport 3.1.3

Answer 6

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}

Answer 7

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 8

delete_if

和

keep_if

都是Ruby核心的一部分。在这里，您可以实现您想要的功能，而无需修补

Hash

类型。

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

有关更多信息，请查看文档中的以下链接：

Answer 9

如果您还想从数据库记录中提取，最好使用

slice

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

https://api.rubyonrails.org/classes/Hash.html#method-i-slice-21

Answer 10

如果你使用rails，使用Hash可能会更方便。除了

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

Answer 11

正如其他人提到的，Ruby 2.5 添加了 Hash#slice 方法。

Rails 5.2.0beta1 还添加了自己的 Hash#slice 版本，为使用早期版本 Ruby 的框架用户提供功能。 https://github.com/rails/rails/commit/01ae39660243bc5f0a986e20f9c9bff312b1b5f8

如果出于某种原因想要实现自己的，这也是一个很好的衬里：

 def slice(*keys)
   keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
 end unless method_defined?(:slice)

Answer 12

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 13

这是建议方法的快速性能比较，

#select

似乎是最快的

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)

细化后将如下所示：

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

并使用它：

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

Answer 14

此代码将您要求的功能注入到 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

并产生您提供的结果：

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}

注意：此方法实际上返回提取的键/值。

Answer 15

如果您不是在 Ruby 2.5 上运行并且您不想通过添加新方法来污染您的 Hash 类，那么这里有一个非常有用的功能解决方案：

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

然后您甚至可以将其应用于嵌套哈希：

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

Answer 16

只是切片方法的补充，如果您想要与原始哈希分离的子哈希键将是动态的，您可以这样做，

slice(*dynamic_keys) # dynamic_keys should be an array type

Answer 17

我们可以通过仅循环我们想要提取的密钥来完成此操作，只需检查密钥是否存在，然后提取它。

class Hash
  def extract(*keys)
    extracted_hash = {}
    keys.each{|key| extracted_hash[key] = self.delete(key) if self.has_key?(key)}
    extracted_hash
  end
end
h1 = {:a => :A, :b => :B, :c => :C, :d => :D}
h2 = h1.extract(:b, :d, :e, :f)

Answer 18

我来到这里是为了寻找 ActiveSupport 自 3.0.0 中提供的细微不同的行为，如

Hash#extract!

:

a = {a: 1, b: 2, c: 3}

b = a.extract!(:b)
# => {b: 2}

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

如何从哈希中提取子哈希？

问题描述投票：0回答：18

18个回答

最新问题

如何从哈希中提取子哈希？

问题描述 投票：0回答：18

18个回答

最新问题

问题描述投票：0回答：18