해시의 모든 키를 루비의 문자열에서 기호로 변환하는 가장 빠른 방법은 무엇입니까?

YAML을 구문 분석 할 때 유용합니다.

my_hash = YAML.load_file('yml')

사용할 수 있기를 원합니다 :

my_hash[:key] 

오히려 :

my_hash['key']

에서 루비> = 2.5 ( 문서 ) 당신은 사용할 수 있습니다 :

my_hash.transform_keys(&:to_sym)

이전 Ruby 버전을 사용하고 있습니까? 다음은 키를 상징으로 해시를 새로운 것으로 복사하는 하나의 라이너입니다.

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

함께 레일 당신은 사용할 수 있습니다 :

my_hash.symbolize_keys
my_hash.deep_symbolize_keys 

Rails를 사용하는 경우 더 나은 방법이 있습니다.

매개 변수. symbolize_keys

끝.

그렇지 않은 경우 코드를 추출하십시오 (링크에도 있음).

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

Ruby에서 특정 YAML의 경우, 키가 ' :'로 시작 하면 자동으로 기호로 삽입됩니다.

'yaml'이 필요합니다
'pp'필요
yaml_str = "
사이:
  -호스트 : host1.example.com
    포트 : 10000
  -호스트 : host2.example.com
    포트 : 20000
"
yaml_sym = "
:사이:
  -: 호스트 : host1.example.com
    포트 : 10000
  -: 호스트 : host2.example.com
    포트 : 20000
"
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
{ "connections"=>
  [{ "port"=> 10000, "host"=> "host1.example.com"},
   { "port"=> 20000, "host"=> "host2.example.com"}]}
끈
{: 연결 수 =>
  [{: port => 10000, : host => "host1.example.com"},
   {: port => 20000, : host => "host2.example.com"}]}
상징

더 간결한 :

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

Rails를 사용하는 경우 훨씬 간단합니다. HashWithIndifferentAccess를 사용하고 문자열 및 기호로 키에 액세스 할 수 있습니다.

my_hash.with_indifferent_access 

또한보십시오:

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

또는 Ruby Core 및 Standard Library 클래스에 대한 많은 확장이 포함 된 멋진 "Facets of Ruby"Gem을 사용할 수 있습니다.

  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_keys나 Hash#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['key'], 또는 mash[:key], 또는mash.key

json을 사용하고 있고 해시로 사용하려는 경우 핵심 Ruby에서 할 수 있습니다.

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

symbolize_names : true로 설정하면 JSON 객체의 이름 (키)에 대한 기호를 반환합니다. 그렇지 않으면 문자열이 반환됩니다. 문자열이 기본값입니다.

문서 : 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_namesJSON 섭취에 따라 옵션을 선택합니다.

레일이 필요 없으며 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}

init 블록이 해시를 업데이트하지 않도록 할 수 있습니다. 이로 인해 이러한 종류의 오류를 방지 할 수는 있지만 여전히 반대의 취약점에 취약합니다. 심볼 버전을 업데이트하면 문자열 버전이 업데이트되지 않습니다.

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 }

해시를 복사하지만 대부분은 신경 쓰지 않습니다. 모든 데이터를 복사하지 않고 할 수있는 방법이있을 것입니다.

짧은 한 줄짜리 술 :

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
• 문자열을 상징하는 것이 일부 정보를 잃는 것을 의미한다면 (해시의 일부를 덮어 씁니다) RuntimeError
• 재귀 적으로 포함 된 해시도 상징
• 상징화 된 해시를 돌려줍니다
• 그 자리에서 작동합니다!

변경하려는 배열입니다.

문자열 = [ "HTML", "CSS", "JavaScript", "Python", "Ruby"]

새 변수를 빈 배열로 만들어 심볼을 ".push"할 수 있도록합니다.

기호 = []

여기서 블록으로 메소드를 정의합니다.

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

코드 끝

따라서 이것은 아마도 Ruby의 배열에서 문자열을 기호로 변환하는 가장 간단한 방법 일 것입니다. 문자열 배열을 만든 다음 새 변수를 만들고 변수를 빈 배열로 설정하십시오. 그런 다음 ".each"메서드로 만든 첫 번째 배열에서 각 요소를 선택하십시오. 그런 다음 블록 코드를 사용하여 새 배열의 모든 요소를 ​​".push"하고 ".intern 또는 .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:자동으로 무시됩니다.

내 우분투 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}

해시 #delete는 삭제 된 키의 값을 반환합니다.

패싯의 해시 #deep_rekey 도 특히 좋은 옵션입니다.

• 프로젝트의 패싯에서 다른 설탕을 사용하는 경우,
• 암호 한 줄짜리보다 코드 가독성을 선호하는 경우.

견본:

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