স্ট্রিংগুলিকে হ্যাশের চিহ্নগুলিতে রূপান্তর করার সর্বোত্তম উপায়

Question

রুবিতে স্ট্রিং থেকে চিহ্নগুলিতে সমস্ত কীগুলি একটি হ্যাশে রূপান্তর করার (দ্রুততম / পরিষ্কার / সরলতম) উপায় কী?

ওয়াইএএমএল পার্স করার সময় এটি কার্যকর হবে।

my_hash = YAML.load_file('yml')

আমি ব্যবহার করতে সক্ষম হতে চাই:

my_hash[:key] 

বরং:

my_hash['key']

Comments

ডুপ ?

— ইয়ান ভন

hash.symbolize_keysএবং hash.deep_symbolize_keysআপনি যদি রেলগুলি ব্যবহার করেন তবে কাজটি করুন।

— জাজ

জোশ যদি আপনি নিজের মন্তব্যে উত্তর দিতেন তবে আমি আপনাকে ভোট দিয়ে দিতাম। 'রেলস' দরকার; হ্যাশ.ডিপ_সিম্বলাইজ_কিগুলি আইআরবি বা পিসিতে বেশ ভালভাবে কাজ করে। : ডি

— ডগলাস জি। অ্যালেন

Answer 1

ইন রুবি> = 2.5 ( ডক্স ) আপনি ব্যবহার করতে পারেন:

my_hash.transform_keys(&:to_sym)

পুরানো রুবি সংস্করণ ব্যবহার করছেন? এখানে একটি ওলাইনার রয়েছে যা প্রতীকী কীগুলির সাহায্যে হ্যাশটিকে একটি নতুন অনুলিপি করবে:

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

সঙ্গে পাগল আপনি ব্যবহার করতে পারেন:

my_hash.symbolize_keys
my_hash.deep_symbolize_keys 

Comments

আহ, অস্পষ্ট হওয়ার জন্য দুঃখিত - ইনজেকশন কলকারীকে সংশোধন করে না। আপনাকে my_hash = my_hash.inject ({}) to | মেমো, (কে, ভি) করতে হবে মেমো [k.to_sym] = ভি; মেমো}

— সারা মেই

ঠিক এটাই আমি খুঁজছিলাম। আমি এটিকে কিছুটা সংশোধন করেছি এবং এমনকি নীচেযুক্ত হ্যাশগুলিতে চিহ্ন তৈরি করতে কিছু লাইন যুক্ত করেছি। আপনি যদি আগ্রহী হন তবে এখানে একবার দেখুন: যে কোনও জায়গায়.ডে

— ম্যাট

রুবি ১.৯ এ আপনি এর each_with_objectমতো ব্যবহার করতে পারেন :my_hash.each_with_object({}){|(k,v), h| h[k.to_sym] = v}

— স্যাজটফ্লোয়েড

এটি পুনরাবৃত্ত হ্যাশগুলি হ্যান্ডেল করে না ... ডিআরওয়াইয়ের জন্য নয় তবে এক বারের জন্য সন্ধান করুন।

— baash05

@BryanM। আমি খুব দেরিতে :-) এই আলোচনায় এসেছি তবে আপনি শেষেটি .tapপাস করার প্রয়োজনটি সরিয়ে ফেলতেও পদ্ধতিটি ব্যবহার করতে পারেন memo। আমি একটি পরিষ্কার সব সমাধান (পাশাপাশি রিকার্সিভ বেশী) সংস্করণ তৈরি করেছি gist.github.com/Integralist/9503099

— Integralist

Answer 2

আপনি যদি রেলগুলি ব্যবহার করেন তবে এখানে একটি আরও ভাল পদ্ধতি রয়েছে:

প্যারাম। symbolize_keys

শেষ।

আপনি যদি না হন তবে কেবল তাদের কোডটি ছিঁড়ে ফেলুন (এটি লিঙ্কটিতেও রয়েছে):

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

Comments

to_options জন্য একটি alias হয় sybolize_keys ।

— ma11 শেই 28

নেস্টেড হ্যাশগুলির প্রতীক হবে না।

— ওমা

আমি symbolize_keysনতুন & কার্যকারী (ব্যঙ্গ 3) ইউআরএল দিয়ে লিঙ্কটি স্যুইচ করেছি । আমি মূলত এর জন্য ইউআরএল ঠিক করেছি to_options, তবে সেই লিঙ্কটিতে শূন্য ডকুমেন্টেশন রয়েছে। symbolize_keysআসলে একটি বিবরণ আছে, তাই আমি পরিবর্তে যে ব্যবহার।

— ক্রেগ ওয়াকার

deep_symbolize_keys! । রেল 2+ এ কাজ করে

— মাস্টব্লাস্টা

বিপরীতে কীভাবে আগ্রহী তাদের পক্ষে hash.stringify_keysকাজ করে।

— নিক

Answer 3

রুবির ওয়াইএএমএল-এর নির্দিষ্ট ক্ষেত্রে, কীগুলি যদি ' :' দিয়ে শুরু হয় তবে সেগুলি স্বয়ংক্রিয়ভাবে প্রতীক হিসাবে অন্তর্ভুক্ত হবে।

'ইয়ামল' প্রয়োজন
'পিপি' প্রয়োজন
yaml_str = "
সংযোগসমূহ:
  - হোস্ট: host1.example.com
    পোর্ট: 10000
  - হোস্ট: host2.example.com
    পোর্ট: 20000
"
yaml_sym = "
: সংযোগসমূহ:
  -: হোস্ট: host1.example.com
    : পোর্ট: 10000
  -: হোস্ট: host2.example.com
    : পোর্ট: 20000
"
পিপি ইয়ামল_স্টার = ইয়ামএল.লোড (ইয়ামল_স্ট্রাস্টার)
yaml_str.keys.first.class রাখে
পিপি ইয়ামল_সাইম = ইয়ামএল.লোড (ইয়ামল_সাইম)
yaml_sym.keys.first.class রাখে

আউটপুট:

# /opt/ruby-1.8.6-p287/bin/ruby test / টেস্ট.আরবি
{ "সংযোগ" =>
  [{"পোর্ট" => 10000, "হোস্ট" => "হোস্ট 1.example.com"},
   port "পোর্ট" => 20000, "হোস্ট" => "হোস্ট 2.example.com"}]}
দড়ি
{: সংযোগ =>
  [{: পোর্ট => 10000,: হোস্ট => "হোস্ট 1.example.com"},
   port: পোর্ট => 20000,: হোস্ট => "হোস্ট 2.example.com"}]}
প্রতীক

Comments

খুব সুন্দর! YAML#load_fileস্ট্রিং w / o এর পরিবর্তে প্রতিটি কীটি কোলন দিয়ে শুরু করার পরিবর্তে সমস্ত কীগুলিকে চিহ্নগুলিতে ডিফল্ট সেট করার উপায় আছে ?

— ma11hew28

Answer 4

আরও বেশি সংশ্লেষ:

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

Comments

এটি সুস্পষ্ট পছন্দ মত মনে হচ্ছে।

— কেসি ওয়াটসন

এটি নেস্টেড হ্যাশগুলির প্রতীক নয়।

— rgtk

আরও পঠনযোগ্য সংস্করণ:my_hash.map { |k, v| [k.to_sym, v] }.to_h

— ডেনিস

Answer 5

আপনি যদি রেলগুলি ব্যবহার করছেন তবে এটি অনেক সহজ you আপনি একটি হ্যাশ উইথইন্ডিফিলারঅ্যাক্সেস ব্যবহার করতে পারেন এবং স্ট্রিং এবং চিহ্ন হিসাবে উভয় কীগুলি অ্যাক্সেস করতে পারেন:

my_hash.with_indifferent_access 

আরো দেখুন:

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

---

অথবা আপনি দারুণ "রুবির মুখগুলি" রত্ন ব্যবহার করতে পারেন, এতে রুবি কোর এবং স্ট্যান্ডার্ড লাইব্রেরি ক্লাসে প্রচুর এক্সটেনশন রয়েছে।

  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

Comments

আসলে যে বিপরীত না। এটি প্রতীক থেকে একটি স্ট্রিতে রূপান্তর করে। প্রতীক রূপান্তর করতে my_hash.symbolize_keys

— এস্পেন

# সিম্বলাইজ_কিগুলি কেবলমাত্র রেলগুলিতে কাজ করে - সরল রুবি / আইআরবিতে নয়। এছাড়াও মনে রাখবেন যে # সিম্বলাইজ_কিগুলি গভীরভাবে নেস্টেড হ্যাশগুলিতে কাজ করে না।

— টিলো

Answer 6

যেহেতু Ruby 2.5.0আপনি ব্যবহার করতে পারেন Hash#transform_keysবা Hash#transform_keys!।

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

Comments

ট্রান্সফর্ম_ভ্যালিউজ apidock.com/rails/Hash/transform_values ​​নিয়েও কাজ করে । এটি সত্যিই দুর্দান্ত কারণ সেখানে মানগুলি সংশোধন করার সমতুল্য বলে মনে হয় না stringify_keysবা আছে বলে symbolize_keys।

— মাইক ভাল্লানো

কী কী গভীর প্রতীকী উপায় আছে

— অভয় কুমার

এটি 2018 এর পরে নির্বাচিত সমাধান হওয়া উচিত

— ইভান ওয়াং

Answer 7

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

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

Answer 8

এখানে কোনও বস্তুর গভীর প্রতীক করার একটি উপায় রয়েছে

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

Comments

খুব সুন্দর, আমি এইটির সাথে যাব যদিও আমি এটির নামকরণ করি গভীর_সঙ্কিত :)

— পিয়েরোজ

Answer 9

আমি সত্যিই ম্যাশ রত্নটি পছন্দ করি ।

আপনি করতে পারেন mash['key'], বা mash[:key], বাmash.key

Comments

এটি একটি দুর্দান্ত মণি! হ্যাশগুলির সাথে কাজ করা খুব আরামদায়ক করে তোলে। এর জন্য ধন্যবাদ!

— আসাকী

খুব সুন্দর সরল। হাশিতে ( github.com/intridea/hashie ) এই প্রকল্পের নতুন বিকাশ অব্যাহত রয়েছে তবে এটি এখনও একইভাবে কাজ করে: github.com/intridea/hashie#keyconversion

— jpalmieri

Answer 10

আপনি যদি জসন ব্যবহার করেন, এবং এটি হ্যাশ হিসাবে ব্যবহার করতে চান তবে মূল রুবি আপনি এটি করতে পারেন:

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

প্রতীকীকরণের নামগুলি: সত্য হিসাবে সেট করা থাকলে, একটি JSON অবজেক্টে নামের (কীগুলি) জন্য প্রতীক প্রত্যাবর্তন করে। অন্যথায় স্ট্রিংগুলি ফিরে আসে। স্ট্রিংগুলি ডিফল্ট।

ডক: জসন # পার্স প্রতীকী_নাম

Comments

symbol_hash = JSON.parse(JSON.generate(YAML.safe_load(FILENAME)), symbolize_names: true)কোনও YAML ফাইল থেকে আগত হলে প্রতীক হিসাবে নেস্টেড কীগুলি সহ দ্রুত একটি হ্যাশ পাওয়ার একটি দুর্দান্ত DRY (তবে অদক্ষ) উপায়।

— ক্যামেরন গ্যাগন

Answer 11

params.symbolize_keysকাজ করবে। এই পদ্ধতিটি হ্যাশ কীগুলি প্রতীকগুলিতে পরিণত করে এবং একটি নতুন হ্যাশ দেয়।

Comments

এই পদ্ধতিটি মূল রুবি নয়। এটি একটি রেলস পদ্ধতি।

— রিকার্ডো একরাস

Answer 12

@ আইগরসলেস উত্তরের একটি পরিবর্তন

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

Comments

আপনি যদি উত্তরের মাধ্যমে লোকেরা স্ক্যান করছেন এমন লোকদের জন্য কেন বস্তুটি সংশোধন করছেন তা অন্তর্ভুক্ত করা যদি সহায়ক হয়।

— Dbz

Answer 13

কারাগারে আপনি ব্যবহার করতে পারেন:

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

রূপান্তর করে:

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

Comments

deep_symbolize_keysরেলের হ্যাশ এক্সটেনশনে যুক্ত করা হয়েছে, তবে এটি রুবি কোরের অংশ নয় not

— রায়ান ক্রিস্পিন হেইনেস 26'18

Answer 14

এখানে অনেক উত্তর, তবে এক পদ্ধতি রেলের কাজ hash.symbolize_keys

Comments

আপনি এটি কেবল রেল ব্যবহার করেই ব্যবহার করতে পারবেন: api.rubyonrails.org/classes/Hash.html#method-i-symbolize_keys এর মধ্যে ডিফল্ট হ্যাশ থাকে না: ডকস.রবি -আলং.আর.ইন

— এডুয়ার্ডো সান্টানা

— রেলগুলি

Answer 15

নেস্টেড হ্যাশগুলির জন্য এটি আমার এক লাইনার

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

Comments

এফওয়াইআই, কেবলমাত্র রেলের জন্য কাজ করে। যে ক্ষেত্রে, হ্যাশ উইথআইডিফিলারএ্যাক্সেস একটি ভাল বিকল্প হতে পারে।

— আদম গ্রান্ট

Answer 16

আপনার এই কারণটি করার দরকার হওয়ার কারণটি হ'ল আপনার ডেটা মূলত জেএসএন থেকে এসেছে, আপনি জেএসওএন ইনজেস্ট করার পরে কেবলমাত্র :symbolize_namesবিকল্পটি পাস করে এই কোনও পার্সিং এড়িয়ে যেতে পারেন ।

কোনও কলের প্রয়োজন নেই এবং রুবি> 1.9 এর সাথে কাজ করে না

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

Answer 17

আপনি অলস হতে পারেন এবং এটিতে একটি জড়ান 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'))

থিম ব্লকটি চাওয়াগুলিতে একবারে কীগুলিকে রূপান্তরিত করবে, যদিও আপনি প্রতীক সংস্করণটি অ্যাক্সেস করার পরে কীটির স্ট্রিং সংস্করণের জন্য মান আপডেট করেন তবে প্রতীক সংস্করণটি আপডেট হবে না।

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}

সুতরাং এগুলি সম্পর্কে যত্নবান হওয়ার বিষয়টি হ'ল দুটি মূল ফর্মের মধ্যে স্যুইচ করা। একটি সঙ্গে লাঠি।

Answer 18

নিম্নলিখিত কাজ মত কিছু করতে চান?

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

এটি হ্যাশটি অনুলিপি করবে, তবে আপনি বেশিরভাগ সময় তার যত্ন নেবেন না। সমস্ত ডেটা অনুলিপি না করে এটি করার একটি উপায় সম্ভবত রয়েছে।

Answer 19

একটি সংক্ষিপ্ত ওয়ান লাইনার fww:

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

Answer 20

এটি সম্পর্কে:

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

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

Answer 21

এটি এমন লোকদের জন্য যাঁরা 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
• যদি স্ট্রিংকে প্রতীকী করা মানে কিছু তথ্য হারানো (হ্যাশের অংশটি ওভাররাইট) বৃদ্ধি করা হয় a RuntimeError
• প্রতীকীভাবে পুনরাবৃত্তভাবে থাকা হ্যাশগুলিও প্রতীক করুন
• প্রতীকী হ্যাশ ফিরিয়ে দিন
• জায়গায় কাজ!

Comments

আপনার পদ্ধতিতে একটি টাইপো আছে, তুমি ভুলে গেছ !মধ্যে symbolize_keys। অন্যথায় ভাল কাজ করে।

— কা মোক

Answer 22

অ্যারে আমরা পরিবর্তন করতে চান।

স্ট্রিংস [["এইচটিএমএল", "সিএসএস", "জাভাস্ক্রিপ্ট", "পাইথন", "রুবি"]

খালি অ্যারে হিসাবে একটি নতুন ভেরিয়েবল তৈরি করুন যাতে আমরা প্রতীকগুলিকে ".পুশ" করতে পারি।

প্রতীকসমূহ = []

আমরা এখানে একটি ব্লক সহ একটি পদ্ধতি সংজ্ঞায়িত করি।

স্ট্রিং.ইচ {| এক্স | symbols.push (x.intern)}

কোডের সমাপ্তি।

সুতরাং এটি সম্ভবত রুবিতে আপনার অ্যারে (গুলি )গুলিতে চিহ্নগুলিতে স্ট্রিংগুলিকে রূপান্তর করার সবচেয়ে সহজ উপায়। স্ট্রিংগুলির একটি অ্যারে তৈরি করুন তারপরে একটি নতুন ভেরিয়েবল তৈরি করুন এবং ভেরিয়েবলটি খালি অ্যারেতে সেট করুন। তারপরে আপনি ".Each" পদ্ধতিতে তৈরি প্রথম অ্যারেতে প্রতিটি উপাদান নির্বাচন করুন। তারপরে আপনার নতুন অ্যারেতে থাকা সমস্ত উপাদানগুলিকে ".পুশ" করতে একটি ব্লক কোড ব্যবহার করুন এবং সমস্ত উপাদানকে প্রতীকগুলিতে রূপান্তর করতে ".ইন্টার্ন বা .to_sym" ব্যবহার করুন।

প্রতীকগুলি দ্রুততর হয় কারণ তারা আপনার কোডের মধ্যে আরও মেমরি সঞ্চয় করে এবং আপনি কেবল সেগুলি একবার ব্যবহার করতে পারেন। প্রতীকগুলি হ্যাশ-এর ​​কীগুলির জন্য সর্বাধিক ব্যবহৃত হয় যা দুর্দান্ত। আমি সেরা রুবি প্রোগ্রামার নই তবে কোডের এই ফর্মটি আমাকে অনেক সহায়তা করেছে anyone যদি কেউ আরও ভাল উপায় জানেন তবে দয়া করে ভাগ করুন এবং আপনি এই পদ্ধতিটি হ্যাশের জন্যও ব্যবহার করতে পারেন!

Comments

প্রশ্নটি হ্যাশ সম্পর্কিত ছিল, অ্যারে নয়।

— রিচার্ড_জি

Answer 23

আপনি যদি ভ্যানিলা রুবি সমাধান চান এবং আমার কাছে অ্যাক্সেস না থাকলে 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

Answer 24

সাইক 3.0 থেকে শুরু করে আপনি প্রতীকী নামগুলি: বিকল্পটি যুক্ত করতে পারেন

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

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

দ্রষ্টব্য: আপনার যদি 3.0 এর চেয়ে কম মানসিক সংস্করণ থাকে symbolize_names:তবে চুপচাপ উপেক্ষা করা হবে।

আমার উবুন্টু 18.04 এ রুবি 2.5.1p57 সহ বক্সের বাইরে এটি অন্তর্ভুক্ত করেছে

Answer 25

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}

Comments

aএটিকে আরও ক্ষতিকারক করার জন্য ব্লক আর্গুমেন্টকে পচন করতে আপনি বন্ধনীগুলিতে মোড়ানো করতে পারেন । উদাহরণস্বরূপ আমার উত্তর দেখুন।

— মাইকেল বার্টন

Answer 26

এটি হুবহু ওয়ান-লাইনার নয়, তবে এটি সমস্ত স্ট্রিং কীগুলিকে প্রতীকগুলিতে এবং নীড়যুক্তদেরও রূপান্তরিত করে:

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

Answer 27

আমি এই ওয়ান-লাইনারটি পছন্দ করি, যখন আমি রেলগুলি ব্যবহার করি না, কারণ তখন প্রক্রিয়া করার সময় আমাকে দ্বিতীয় হ্যাশ তৈরি করতে এবং দুটি সেট ডেটা ধরে রাখতে হবে না:

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}

হ্যাশ # ডিলিট মুছে ফেলা কীটির মান প্রদান করে

Answer 28

মুখের হ্যাশ # ডিপ_রেকি একটি ভাল বিকল্প, বিশেষত:

• যদি আপনি আপনার প্রকল্পের দিকগুলি থেকে অন্য চিনির ব্যবহার খুঁজে পান,
• আপনি যদি ক্রিপ্টিকাল ওয়ান-লাইনারের চেয়ে কোড পঠনযোগ্যতা পছন্দ করেন।

নমুনা:

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

Answer 29

রুবিতে আমি এটি হ্যাশগুলিতে চিহ্নগুলিতে স্ট্রিং কীগুলি ঘুরিয়ে দেওয়ার সবচেয়ে সহজ এবং সহজে বোঝার উপায় বলে মনে করি:

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

হ্যাশের প্রতিটি কী এর জন্য আমরা এটিতে মুছে ফেলার কল করি যা এটি হ্যাশ থেকে সরিয়ে দেয় (মুছে ফেলা কীটির সাথে সম্পর্কিত মানটিও মুছুন ) এবং আমরা তত্ক্ষণাত এটিকে প্রতীকী কীটির সমান সেট করি।

Answer 30

পূর্ববর্তী সমাধানগুলির মতো তবে কিছুটা ভিন্নভাবে লেখা।

• এটি নেস্টযুক্ত এবং / অথবা অ্যারেযুক্ত একটি হ্যাশের অনুমতি দেয়।
• বোনাস হিসাবে একটি স্ট্রিংতে কীগুলির রূপান্তর পান Get

• কোডটি রূপান্তরিত করে না হ্যাশটি পাস হয়েছে।

  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