Ruby哈希 #

hash = { name: "Ruby", version: 3.3 }
hash.class
hash.length

hash = {}
hash = { "name" => "Ruby", "version" => 3.3 }
hash = { name: "Ruby", version: 3.3 }
hash = { :name => "Ruby", :version => 3.3 }
hash = { "name" => "Ruby", age: 30 }

Hash.new
Hash.new("default")
Hash.new { |h, k| h[k] = [] }
Hash[]
Hash[a: 1, b: 2]
Hash[[[:a, 1], [:b, 2]]]
Hash["a", 1, "b", 2]

[[:a, 1], [:b, 2]].to_h
[[:a, 1], [:b, 2]].each_with_object({}) { |(k, v), h| h[k] = v }
Array.new(3) { |i| [i, i * 2] }.to_h
(1..3).map { |i| [i, i ** 2] }.to_h

hash = { name: "Ruby", version: 3.3 }

hash[:name]
hash["name"]
hash[:nonexistent]
hash[:nonexistent] || "default"
hash.fetch(:name)
hash.fetch(:nonexistent, "default")
hash.fetch(:nonexistent) { |k| "#{k} not found" }

hash = { user: { profile: { name: "Ruby" } } }

hash.dig(:user, :profile, :name)
hash.dig(:user, :settings, :theme)
hash[:user]&.[](:profile)&.[](:name)

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

hash.values_at(:a, :b)
hash.values_at(:a, :d)
hash.fetch_values(:a, :b)
hash.fetch_values(:a, :d) { |k| "#{k} missing" }

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

hash.slice(:a, :b)
hash.slice(:a, :e)
hash.except(:a, :b)

hash = { a: 1 }

hash[:b] = 2
hash.store(:c, 3)
hash.merge!({ d: 4, e: 5 })
hash.replace({ x: 1, y: 2 })

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

hash.delete(:a)
hash.delete(:nonexistent)
hash.delete(:nonexistent) { |k| "#{k} not found" }
hash.delete_if { |k, v| v > 1 }
hash.reject! { |k, v| v > 1 }
hash.keep_if { |k, v| v > 1 }
hash.select! { |k, v| v > 1 }
hash.compact!
hash.transform_values! { |v| v * 2 }
hash.clear

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

hash.shift
hash.shift

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

hash.key?(:a)
hash.has_key?(:a)
hash.include?(:a)
hash.member?(:a)
hash.keys
hash.key(1)

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

hash.value?(1)
hash.has_value?(1)
hash.values
hash.value?(10)

hash = {}

hash.empty?
hash.nil?
hash.length
hash.size
hash.count
hash.count { |k, v| v > 1 }

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

hash.each { |k, v| puts "#{k}: #{v}" }
hash.each_key { |k| puts k }
hash.each_value { |v| puts v }
hash.each_pair { |k, v| puts "#{k}: #{v}" }

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

hash.map { |k, v| [k, v * 2] }.to_h
hash.transform_values { |v| v * 2 }
hash.transform_keys { |k| k.to_s }
hash.transform_keys(&:to_s)
hash.transform_keys!(&:to_s)
hash.transform_values! { |v| v * 2 }

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

hash.select { |k, v| v.even? }
hash.reject { |k, v| v.even? }
hash.filter { |k, v| v > 2 }
hash.select! { |k, v| v.even? }

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

hash.reduce(0) { |sum, (k, v)| sum + v }
hash.reduce({}) { |h, (k, v)| h[k.to_s] = v; h }
hash.each_with_object([]) { |(k, v), arr| arr << "#{k}=#{v}" }

h1 = { a: 1, b: 2 }
h2 = { b: 3, c: 4 }

h1.merge(h2)
h1.merge(h2) { |k, v1, v2| v1 + v2 }
h1.merge!(h2)
h1.reverse_merge(h2)

h1 = { a: 1, b: 2 }
h2 = { b: 3, c: 4 }

h1.merge(h2)
h2.merge(h1)
h1.merge(h2) { |k, old, new| old }
h1.merge(h2) { |k, old, new| new }
h1.merge(h2) { |k, old, new| old + new }

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

hash.to_a
hash.to_s
hash.inspect
hash.flatten
hash.keys
hash.values
hash.to_h

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

hash.invert
hash.invert.invert

require 'json'

hash = { name: "Ruby", version: 3.3 }
hash.to_json
JSON.generate(hash)
JSON.parse(hash.to_json)

hash = Hash.new(0)
hash[:a] += 1
hash[:a]
hash[:b]

hash = Hash.new { |h, k| h[k] = [] }
hash[:a] << 1
hash[:a]
hash[:b]

hash = { a: 1 }

hash.default
hash.default = 0
hash.default_proc
hash.default_proc = proc { |h, k| h[k] = [] }

hash = Hash.new([])
hash[:a] << 1
hash[:b]
hash[:a].object_id == hash[:b].object_id

hash = Hash.new { |h, k| h[k] = [] }
hash[:a] << 1
hash[:b]

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

hash.sort
hash.sort.to_h
hash.keys.sort
hash.sort_by { |k, v| k }

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

hash.sort_by { |k, v| v }
hash.sort_by { |k, v| v }.to_h
hash.sort_by { |k, v| -v }.to_h
hash.sort_by(&:last).to_h

hash = {
  user: {
    name: "Ruby",
    profile: {
      age: 30,
      city: "Beijing"
    }
  }
}

hash = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
hash[:a][:b][:c] = 1

hash = { user: { profile: { name: "Ruby" } } }

hash[:user][:profile][:name]
hash.dig(:user, :profile, :name)
hash.dig(:user, :settings, :theme)
hash.fetch(:user).fetch(:profile).fetch(:name)

def deep_merge(h1, h2)
  h1.merge(h2) do |k, v1, v2|
    if v1.is_a?(Hash) && v2.is_a?(Hash)
      deep_merge(v1, v2)
    else
      v2
    end
  end
end

h1 = { a: { b: 1, c: 2 } }
h2 = { a: { c: 3, d: 4 } }
deep_merge(h1, h2)

def word_count(text)
  text.split.each_with_object(Hash.new(0)) { |word, hash| hash[word] += 1 }
end

word_count("hello world hello ruby world")

def group_by_key(items, key)
  items.group_by { |item| item[key] }
end

users = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Charlie", age: 25 }
]

group_by_key(users, :age)

class HashPath
  def self.get(hash, path)
    keys = path.to_s.split(".")
    keys.reduce(hash) { |h, k| h&.[](k.to_sym) || h&.[](k) }
  end

  def self.set(hash, path, value)
    keys = path.to_s.split(".")
    last_key = keys.pop
    target = keys.reduce(hash) { |h, k| h[k.to_sym] ||= {} }
    target[last_key.to_sym] = value
    hash
  end
end

data = { user: { profile: { name: "Ruby" } } }
HashPath.get(data, "user.profile.name")
HashPath.set(data, "user.profile.age", 30)

def hash_diff(h1, h2)
  keys = (h1.keys | h2.keys)
  keys.each_with_object({}) do |key, diff|
    if h1[key] != h2[key]
      diff[key] = { old: h1[key], new: h2[key] }
    end
  end
end

hash_diff({ a: 1, b: 2 }, { a: 1, b: 3, c: 4 })

def symbolize_keys(hash)
  hash.transform_keys { |k| k.to_sym rescue k }
end

def deep_symbolize_keys(hash)
  hash.transform_keys(&:to_sym).transform_values do |v|
    v.is_a?(Hash) ? deep_symbolize_keys(v) : v
  end
end

symbolize_keys({ "name" => "Ruby", "age" => 30 })
deep_symbolize_keys({ "user" => { "name" => "Ruby" } })