อะไรคือวิธีที่เร็วที่สุด / สะอาด / ตรงไปตรงมาในการแปลงคีย์ทั้งหมดในแฮชจากสตริงเป็นสัญลักษณ์ในรูบี

นี่จะเป็นประโยชน์เมื่อแยกวิเคราะห์ YAML

my_hash = YAML.load_file('yml')

ฉันต้องการใช้:

my_hash[:key] 

ค่อนข้างมากกว่า:

my_hash['key']

ในRuby> = 2.5 ( เอกสาร ) คุณสามารถใช้:

my_hash.transform_keys(&:to_sym)

ใช้รุ่น Ruby รุ่นเก่าหรือไม่ นี่คือสายการบินหนึ่งที่จะคัดลอกแฮชลงในอันใหม่ที่มีปุ่มสัญลักษณ์:

my_hash = my_hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}

ด้วยRailsคุณสามารถใช้:

my_hash.symbolize_keys
my_hash.deep_symbolize_keys 

นี่เป็นวิธีที่ดีกว่าถ้าคุณใช้ Rails:

params symbolize_keys

ตอนจบ.

หากคุณไม่ได้เป็นเพียงแค่ฉีกรหัสของพวกเขา (ยังอยู่ในลิงค์):

myhash.keys.each do |key|
  myhash[(key.to_sym rescue key) || key] = myhash.delete(key)
end

สำหรับกรณีเฉพาะของ YAML ใน Ruby หากคีย์เริ่มต้นด้วย ' :' พวกเขาจะถูก interned เป็นสัญลักษณ์โดยอัตโนมัติ

ต้องการ 'yaml'
ต้องการ 'pp'
yaml_str = "
การเชื่อมต่อ:
  - โฮสต์: host1.example.com
    พอร์ต: 10,000
  - โฮสต์: host2.example.com
    พอร์ต: 20,000
"
yaml_sym = "
: การเชื่อมต่อ:
  -: host: host1.example.com
    : พอร์ต: 10000
  -: host: host2.example.com
    : พอร์ต: 20,000
"
pp yaml_str = YAML.load (yaml_str)
วาง yaml_str.keys.first.class
pp yaml_sym = YAML.load (yaml_sym)
วาง yaml_sym.keys.first.class

เอาท์พุท:

# /opt/ruby-1.8.6-p287/bin/ruby ~ / test.rb
{ "การเชื่อมต่อ" =>
  [{"พอร์ต" => 10000, "host" => "host1.example.com"},
   {"พอร์ต" => 20000, "โฮสต์" => "host2.example.com"}]}
เชือก
{: การเชื่อมต่อ =>
  [{: พอร์ต => 10000,: host => "host1.example.com"},
   {: พอร์ต => 20000,: host => "host2.example.com"}]}
สัญลักษณ์

ยิ่งบทสรุป:

Hash[my_hash.map{|(k,v)| [k.to_sym,v]}]

หากคุณใช้ Rails จะง่ายกว่ามาก - คุณสามารถใช้ HashWithIndifferentAccess และเข้าถึงกุญแจได้ทั้งแบบ String และสัญลักษณ์:

my_hash.with_indifferent_access 

ดูสิ่งนี้ด้วย:

http://api.rubyonrails.org/classes/ActiveSupport/HashWithIndifferentAccess.html

หรือคุณสามารถใช้ Gem "Facets of Ruby" ที่ยอดเยี่ยมซึ่งมีส่วนขยายจำนวนมากสำหรับคลาส Ruby Core และ Standard Library

  require 'facets'
  > {'some' => 'thing', 'foo' => 'bar'}.symbolize_keys
    =>  {:some=>"thing", :foo=>"bar}

ดูเพิ่มเติมที่: http://rubyworks.github.io/rubyfaux/?doc=http://rubyworks.github.io/facets/docs/facets-2.9.3/core.json#api-class-Hash

ตั้งแต่Ruby 2.5.0คุณสามารถใช้หรือHash#transform_keysHash#transform_keys!

{'a' => 1, 'b' => 2}.transform_keys(&:to_sym) #=> {:a => 1, :b => 2}

http://api.rubyonrails.org/classes/Hash.html#method-i-symbolize_keys

hash = { 'name' => 'Rob', 'age' => '28' }
hash.symbolize_keys
# => { name: "Rob", age: "28" }

นี่คือวิธีในการทำสัญลักษณ์วัตถุให้ลึก

def symbolize(obj)
    return obj.inject({}){|memo,(k,v)| memo[k.to_sym] =  symbolize(v); memo} if obj.is_a? Hash
    return obj.inject([]){|memo,v    | memo           << symbolize(v); memo} if obj.is_a? Array
    return obj
end

ฉันชอบอัญมณีMash

คุณสามารถทำmash['key']หรือmash[:key]หรือหรือmash.key

หากคุณใช้ json และต้องการใช้เป็นแฮชใน core Ruby คุณสามารถทำได้:

json_obj = JSON.parse(json_str, symbolize_names: true)

symbolize_names : ถ้าตั้งค่าเป็น True จะส่งคืนสัญลักษณ์สำหรับชื่อ (คีย์) ในวัตถุ JSON มิฉะนั้นจะถูกส่งกลับสตริง สตริงเป็นค่าเริ่มต้น

Doc: Json # parse symbolize_names

params.symbolize_keysยังจะทำงาน วิธีนี้เปลี่ยนแป้นแฮชเป็นสัญลักษณ์และส่งคืนแฮชใหม่

การแก้ไขคำตอบ @igorsales

class Object
  def deep_symbolize_keys
    return self.inject({}){|memo,(k,v)| memo[k.to_sym] = v.deep_symbolize_keys; memo} if self.is_a? Hash
    return self.inject([]){|memo,v    | memo           << v.deep_symbolize_keys; memo} if self.is_a? Array
    return self
  end
end

ใน Rails คุณสามารถใช้:

{'g'=> 'a', 2 => {'v' => 'b', 'x' => { 'z' => 'c'}}}.deep_symbolize_keys!

เปลี่ยนเป็น:

{:g=>"a", 2=>{:v=>"b", :x=>{:z=>"c"}}}

คำตอบมากมายที่นี่ แต่ฟังก์ชั่นรางวิธีหนึ่งคือ hash.symbolize_keys

นี่เป็นซับในสำหรับแฮชซ้อนกัน

def symbolize_keys(hash)
  hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v }
end

ในกรณีที่เหตุผลที่คุณต้องทำคือเนื่องจากข้อมูลของคุณมาจาก JSON คุณสามารถข้ามการแยกวิเคราะห์ใด ๆ โดยเพียงผ่านใน:symbolize_namesตัวเลือกในการบริโภค JSON

ไม่จำเป็นต้องใช้ Rails และทำงานกับ Ruby> 1.9

JSON.parse(my_json, :symbolize_names => true)

คุณอาจขี้เกียจและห่อไว้ในlambda:

my_hash = YAML.load_file('yml')
my_lamb = lambda { |key| my_hash[key.to_s] }

my_lamb[:a] == my_hash['a'] #=> true

แต่วิธีนี้ใช้ได้กับการอ่านจากแฮชเท่านั้น - ไม่ใช่การเขียน

ในการทำเช่นนั้นคุณสามารถใช้ Hash#merge

my_hash = Hash.new { |h,k| h[k] = h[k.to_s] }.merge(YAML.load_file('yml'))

บล็อก init จะแปลงคีย์แบบครั้งเดียวตามต้องการแม้ว่าคุณจะอัปเดตค่าสำหรับรุ่นสตริงของคีย์หลังจากเข้าถึงเวอร์ชันสัญลักษณ์เวอร์ชันสัญลักษณ์จะไม่ถูกอัพเดต

irb> x = { 'a' => 1, 'b' => 2 }
#=> {"a"=>1, "b"=>2}
irb> y = Hash.new { |h,k| h[k] = h[k.to_s] }.merge(x)
#=> {"a"=>1, "b"=>2}
irb> y[:a]  # the key :a doesn't exist for y, so the init block is called
#=> 1
irb> y
#=> {"a"=>1, :a=>1, "b"=>2}
irb> y[:a]  # the key :a now exists for y, so the init block is isn't called
#=> 1
irb> y['a'] = 3
#=> 3
irb> y
#=> {"a"=>3, :a=>1, "b"=>2}

คุณสามารถมีบล็อกเริ่มต้นไม่อัปเดตแฮชซึ่งจะป้องกันคุณจากข้อผิดพลาดประเภทนั้น แต่คุณยังคงมีความเสี่ยงที่ตรงกันข้าม - การอัปเดตเวอร์ชันสัญลักษณ์จะไม่อัปเดตเวอร์ชันสตริง:

irb> q = { 'c' => 4, 'd' => 5 }
#=> {"c"=>4, "d"=>5}
irb> r = Hash.new { |h,k| h[k.to_s] }.merge(q)
#=> {"c"=>4, "d"=>5}
irb> r[:c] # init block is called
#=> 4
irb> r
#=> {"c"=>4, "d"=>5}
irb> r[:c] # init block is called again, since this key still isn't in r
#=> 4
irb> r[:c] = 7
#=> 7
irb> r
#=> {:c=>7, "c"=>4, "d"=>5}

ดังนั้นสิ่งที่ต้องระวังด้วยสิ่งเหล่านี้คือการสลับระหว่างสองรูปแบบที่สำคัญ ติดกับหนึ่ง

มีบางอย่างที่ต้องการทำงานต่อไปนี้หรือไม่

new_hash = Hash.new
my_hash.each { |k, v| new_hash[k.to_sym] = v }

มันจะคัดลอกแฮช แต่คุณจะไม่สนใจเวลาส่วนใหญ่ อาจเป็นวิธีที่ทำได้โดยไม่ต้องคัดลอกข้อมูลทั้งหมด

fwiw หนึ่งซับที่สั้นกว่า:

my_hash.inject({}){|h,(k,v)| h.merge({ k.to_sym => v}) }

เกี่ยวกับสิ่งนี้:

my_hash = HashWithIndifferentAccess.new(YAML.load_file('yml'))

# my_hash['key'] => "val"
# my_hash[:key]  => "val"

สิ่งนี้มีไว้สำหรับผู้ที่ใช้mrubyและไม่ได้symbolize_keysกำหนดวิธีการใด ๆไว้:

class Hash
  def symbolize_keys!
    self.keys.each do |k|
      if self[k].is_a? Hash
        self[k].symbolize_keys!
      end
      if k.is_a? String
        raise RuntimeError, "Symbolizing key '#{k}' means overwrite some data (key :#{k} exists)" if self[k.to_sym]
        self[k.to_sym] = self[k]
        self.delete(k)
      end
    end
    return self
  end
end

วิธีการ:

• เป็นสัญลักษณ์ของคีย์เท่านั้น String
• ถ้า symbolize สตริงหมายถึงการสูญเสียข้อมูลบางส่วน (เขียนทับส่วนของแฮช) ให้เพิ่ม RuntimeError
• เป็นสัญลักษณ์นอกจากนี้ยังมีแฮชแบบเรียกซ้ำ
• ส่งคืนแฮชที่เป็นสัญลักษณ์
• ทำงานในสถานที่!

อาร์เรย์ที่เราต้องการเปลี่ยน

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"]

สร้างตัวแปรใหม่เป็นอาร์เรย์ว่างเพื่อให้เราสามารถ ".push" สัญลักษณ์

สัญลักษณ์ = []

ที่นี่เราจะกำหนดวิธีการด้วยบล็อก

strings.each {| x | symbols.push (x.intern)}

จุดสิ้นสุดของรหัส

ดังนั้นนี่อาจเป็นวิธีที่ตรงไปตรงมาที่สุดในการแปลงสตริงเป็นสัญลักษณ์ในอาร์เรย์ของคุณใน Ruby สร้างอาร์เรย์ของสตริงจากนั้นสร้างตัวแปรใหม่และตั้งค่าตัวแปรเป็นอาร์เรย์ว่าง จากนั้นเลือกแต่ละองค์ประกอบในอาร์เรย์แรกที่คุณสร้างด้วยวิธี ".each" จากนั้นใช้รหัสบล็อกเพื่อ ".push" องค์ประกอบทั้งหมดในอาร์เรย์ใหม่ของคุณและใช้ ".internet หรือ. to_sym" เพื่อแปลงองค์ประกอบทั้งหมดเป็นสัญลักษณ์

สัญลักษณ์เร็วขึ้นเพราะพวกเขาบันทึกหน่วยความจำภายในรหัสของคุณและคุณสามารถใช้ได้เพียงครั้งเดียว สัญลักษณ์ที่ใช้บ่อยที่สุดสำหรับกุญแจในแฮชที่ดี ฉันไม่ใช่โปรแกรมเมอร์ทับทิมที่ดีที่สุด แต่รหัสรูปแบบนี้ช่วยฉันได้มากหากใครรู้วิธีที่ดีกว่าโปรดแชร์และคุณสามารถใช้วิธีนี้เพื่อแฮชได้เช่นกัน!

หากคุณต้องการวิธีการแก้ปัญหาวานิลลาทับทิมและในขณะที่ฉันไม่สามารถเข้าถึงActiveSupportที่นี่เป็นโซลูชั่นสัญลักษณ์ลึก (คล้ายกับคนก่อนหน้า)

    def deep_convert(element)
      return element.collect { |e| deep_convert(e) } if element.is_a?(Array)
      return element.inject({}) { |sh,(k,v)| sh[k.to_sym] = deep_convert(v); sh } if element.is_a?(Hash)
      element
    end

เริ่มต้นที่Psych 3.0 คุณสามารถเพิ่มตัวเลือกsymbolize_names:

Psych.load("---\n foo: bar") # => {"foo"=>"bar"}

Psych.load("---\n foo: bar", symbolize_names: true) # => {:foo=>"bar"}

หมายเหตุ: หากคุณมีเวอร์ชัน Psych ต่ำกว่า 3.0 symbolize_names:จะถูกเพิกเฉยอย่างเงียบ ๆ

Ubuntu ของฉัน 18.04 รวมเอาไว้ในกล่องด้วยทับทิม 2.5.1p57

ruby-1.9.2-p180 :001 > h = {'aaa' => 1, 'bbb' => 2}
 => {"aaa"=>1, "bbb"=>2} 
ruby-1.9.2-p180 :002 > Hash[h.map{|a| [a.first.to_sym, a.last]}]
 => {:aaa=>1, :bbb=>2}

นี่ไม่ใช่ซับเส้นเดียว แต่เปลี่ยนเป็นคีย์สตริงทั้งหมดเป็นสัญลักษณ์รวมถึงสตริงซ้อนกัน:

def recursive_symbolize_keys(my_hash)
  case my_hash
  when Hash
    Hash[
      my_hash.map do |key, value|
        [ key.respond_to?(:to_sym) ? key.to_sym : key, recursive_symbolize_keys(value) ]
      end
    ]
  when Enumerable
    my_hash.map { |value| recursive_symbolize_keys(value) }
  else
    my_hash
  end
end

ฉันชอบซับในตัวนี้เมื่อฉันไม่ได้ใช้ Rails เพราะฉันไม่ต้องแฮชที่สองและเก็บข้อมูลสองชุดในขณะที่ฉันกำลังประมวลผล:

my_hash = { "a" => 1, "b" => "string", "c" => true }

my_hash.keys.each { |key| my_hash[key.to_sym] = my_hash.delete(key) }

my_hash
=> {:a=>1, :b=>"string", :c=>true}

Hash # delete ส่งคืนค่าของคีย์ที่ถูกลบ

Hash # deep_rekey ของ Facetsเป็นตัวเลือกที่ดีเช่นกันโดยเฉพาะ:

• หากคุณพบว่าใช้สำหรับน้ำตาลอื่นจากแง่มุมในโครงการของคุณ
• หากคุณต้องการให้อ่านรหัสได้ง่ายกว่า cryptical one-liners

ตัวอย่าง:

require 'facets/hash/deep_rekey'
my_hash = YAML.load_file('yml').deep_rekey

ในทับทิมฉันคิดว่านี่เป็นวิธีที่ง่ายและเข้าใจง่ายที่สุดในการเปลี่ยนคีย์สตริงเป็นแฮชเป็นสัญลักษณ์:

my_hash.keys.each { |key| my_hash[key.to_sym] = my_hash.delete(key)}

สำหรับแต่ละคีย์ในแฮชเราจะเรียก delete บนมันซึ่งจะลบมันออกจากแฮช (เช่น delete จะคืนค่าที่เกี่ยวข้องกับคีย์ที่ถูกลบ) และเราตั้งค่านี้ทันทีเท่ากับคีย์สัญลักษณ์

คล้ายกับโซลูชันก่อนหน้า แต่เขียนแตกต่างกันเล็กน้อย

• วิธีนี้ช่วยให้แฮชที่ซ้อนอยู่และ / หรือมีอาร์เรย์
• รับการแปลงคีย์เป็นสตริงเป็นโบนัส

• รหัสไม่กลายพันธุ์แฮถูกส่งผ่านมา

  module HashUtils
    def symbolize_keys(hash)
      transformer_function = ->(key) { key.to_sym }
      transform_keys(hash, transformer_function)
    end
  
    def stringify_keys(hash)
      transformer_function = ->(key) { key.to_s }
      transform_keys(hash, transformer_function)
    end
  
    def transform_keys(obj, transformer_function)
      case obj
      when Array
        obj.map{|value| transform_keys(value, transformer_function)}
      when Hash
        obj.each_with_object({}) do |(key, value), hash|
          hash[transformer_function.call(key)] = transform_keys(value, transformer_function)
        end
      else
        obj
      end
    end
  end