在 Ruby 中将嵌套哈希键从 CamelCase 转换为 Snake_case

Question

我正在尝试构建一个 API 包装器 gem，并且在将哈希键从 API 返回的 JSON 转换为更 Rubyish 格式时遇到问题。

JSON 包含多层嵌套，包括哈希和数组。我想要做的是将所有键递归地转换为snake_case以方便使用。

这是我到目前为止所得到的：

def convert_hash_keys(value)
  return value if (not value.is_a?(Array) and not value.is_a?(Hash))
  result = value.inject({}) do |new, (key, value)|
    new[to_snake_case(key.to_s).to_sym] = convert_hash_keys(value)
    new
  end
  result
end

上面调用此方法将字符串转换为snake_case：

def to_snake_case(string)
  string.gsub(/::/, '/').
  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
  gsub(/([a-z\d])([A-Z])/,'\1_\2').
  tr("-", "_").
  downcase
end

理想情况下，结果将类似于以下内容：

hash = {:HashKey => {:NestedHashKey => [{:Key => "value"}]}}

convert_hash_keys(hash)
# => {:hash_key => {:nested_hash_key => [{:key => "value"}]}}

我的递归错误，并且我遇到过此类解决方案的每个版本尝试要么不转换超出第一级的符号，要么过度尝试转换整个散列，包括值。

如果可能的话，尝试在辅助类中解决所有这些问题，而不是修改实际的哈希和字符串函数。

先感谢您。

Answer 1

如果您使用Rails：

哈希示例：camelCase 到 Snake_case：

hash = { camelCase: 'value1', changeMe: 'value2' }

hash.transform_keys { |key| key.to_s.underscore }
# => { "camel_case" => "value1", "change_me" => "value2" }

来源：
http://apidock.com/rails/v4.0.2/Hash/transform_keys

对于嵌套属性，请使用 deep_transform_keys 而不是 transform_keys，示例：

hash = { camelCase: 'value1', changeMe: { hereToo: { andMe: 'thanks' } } }

hash.deep_transform_keys { |key| key.to_s.underscore }
# => {"camel_case"=>"value1", "change_me"=>{"here_too"=>{"and_me"=>"thanks"}}}

来源：http://apidock.com/rails/v4.2.7/Hash/deep_transform_keys

Answer 2

你需要分别对待Array和Hash。而且，如果您使用 Rails，则可以使用 下划线< /code>而不是你的自制 to_snake_case。首先是一个减少噪音的小帮手：

def underscore_key(k)
  k.to_s.underscore.to_sym
  # Or, if you're not in Rails:
  # to_snake_case(k.to_s).to_sym
end

如果你的散列有不是符号或字符串的键，那么你可以适当地修改 underscore_key 。

如果您有一个数组，那么您只想递归地将 convert_hash_keys 应用于数组的每个元素；如果您有哈希，则需要使用 underscore_key 修复键并将 convert_hash_keys 应用于每个值；如果你还有其他东西，那么你想将其原样传递：

def convert_hash_keys(value)
  case value
    when Array
      value.map { |v| convert_hash_keys(v) }
      # or `value.map(&method(:convert_hash_keys))`
    when Hash
      Hash[value.map { |k, v| [underscore_key(k), convert_hash_keys(v)] }]
    else
      value
   end
end

Answer 3

我使用这个简短的形式：

hash.transform_keys(&:underscore)

并且，正如 @Shanaka Kuruwita 指出的那样，深度转换所有嵌套的哈希值：

hash.deep_transform_keys(&:underscore)

Answer 4

“mu 太短”接受的答案已转换为 gem，futurechimp 的 Plissken：

https://github.com/futurechimp/plissken/blob/master/lib/plissken/ext/hash/to_snake_keys.rb

这看起来应该在 Rails 之外作为下划线功能工作包括在内。

Answer 5

使用 deep_transform_keys 进行递归转换。

transform_keys 仅在高级中转换它。

hash = { camelCase: 'value1', changeMe: {nestedMe: 'value2'} }

hash.transform_keys { |key| key.to_s.underscore }
# => { "camel_case" => "value1", "change_me" => {nestedMe: 'value2'} }

deep_transform_keys 将更深入并转换所有嵌套的哈希值。

hash = { camelCase: 'value1', changeMe: {nestedMe: 'value2'} }

hash.deep_transform_keys { |key| key.to_s.underscore }
# => { "camel_case" => "value1", "change_me" => {nested_me: 'value2'} }

Answer 6

如果您使用的是 active_support 库，则可以使用 deep_transform_keys！像这样：

hash.deep_transform_keys! do |key|
  k = key.to_s.snakecase rescue key
  k.to_sym rescue key
end

Answer 7

这适用于对象的 camelCase 和 snake_case 深层嵌套键，这对于 JSON API 非常有用：

def camelize_keys(object)
  deep_transform_keys_in_object!(object) { |key| key.to_s.camelize(:lower) }
end

def snakecase_keys(object)
  deep_transform_keys_in_object!(object) { |key| key.to_s.underscore.to_sym }
end

def deep_transform_keys_in_object!(object, &block)
  case object
  when Hash
    object.keys.each do |key|
      value = object.delete(key)
      object[yield(key)] = deep_transform_keys_in_object!(value, &block)
    end
    object
  when Array
    object.map! { |e| deep_transform_keys_in_object!(e, &block) }
  else
    object
  end
end