仅适用于Rails 5

Question

正如您所知，JSON命名约定主张使用camelSpace，Rails主张使用snake_case作为参数名称。

在rails控制器中将所有请求的参数转换为snake_case的最佳方法是什么？

由此：

{
  ...
  "firstName": "John",
  "lastName": "Smith",
  "moreInfo":
  {
    "mealType": 2,
    "mealSize": 4,
    ...
  }
}

到此：

{
  ...
  "first_name": "John",
  "last_name": "Smith",
  "more_info":
  {
    "meal_type": 2,
    "meal_size": 4,
    ...
  }
}

谢谢

Answer 1

完成以下步骤后，通过JSON请求提交的camelCase参数名称将更改为snake_case。

例如，名为passwordConfirmation的JSON请求参数将在控制器中以params[:password_confirmation]

的形式访问

在config/initializers/json_param_key_transform.rb创建初始值设定项。此文件将仅更改JSON请求的参数解析行为（JSON请求必须具有请求标头Content-Type: application/json）。

找到您的Rails版本并选择下面的相应部分（在Gemfile.lock中找到您的Rails版本）：

仅适用于Rails 5

对于Rails 5，要将camel-case param键转换为snake-case，请将其放入初始值设定项中：

# File: config/initializers/json_param_key_transform.rb
# Transform JSON request param keys from JSON-conventional camelCase to
# Rails-conventional snake_case:
ActionDispatch::Request.parameter_parsers[:json] = -> (raw_post) {
  # Modified from action_dispatch/http/parameters.rb
  data = ActiveSupport::JSON.decode(raw_post)
  data = {:_json => data} unless data.is_a?(Hash)

  # Transform camelCase param keys to snake_case:
  data.deep_transform_keys!(&:underscore)
}

对于Rails 4.2（可能是早期版本）

对于Rails 4.2（可能是早期版本），要将camel-case param键转换为snake-case，请将其放在初始化程序中：

# File: config/initializers/json_param_key_transform.rb
# Transform JSON request param keys from JSON-conventional camelCase to
# Rails-conventional snake_case:
Rails.application.config.middleware.swap(
  ::ActionDispatch::ParamsParser, ::ActionDispatch::ParamsParser,
  ::Mime::JSON => Proc.new { |raw_post|

    # Borrowed from action_dispatch/middleware/params_parser.rb except for
    # data.deep_transform_keys!(&:underscore) :
    data = ::ActiveSupport::JSON.decode(raw_post)
    data = {:_json => data} unless data.is_a?(::Hash)
    data = ::ActionDispatch::Request::Utils.deep_munge(data)

    # Transform camelCase param keys to snake_case:
    data.deep_transform_keys!(&:underscore)

    data.with_indifferent_access
  }
)

所有Rails版本的最后一步

重新启动rails server。

Answer 2

ActiveSupport已经提供了String＃snakecase方法。您所要做的就是安装一个过滤器，该过滤器通过params散列进行深度迭代，并用key.snakecase替换键。

before_filter :deep_snake_case_params!

def deep_snake_case_params!(val = params)
  case val
  when Array
    val.map {|v| deep_snake_case_params! v }
  when Hash
    val.keys.each do |k, v = val[k]|
      val.delete k
      val[k.snakecase] = deep_snake_case_params!(v)
    end
    val
  else
    val
  end
end

Answer 3

将Sebastian Hoitz的答案与this gist合并，我可以在rails 4.2上使用wrap_parameters标记方法包装的强参数和参数。

我无法使用before_filter使其工作，可能是因为参数包装是在过滤之前完成的。

在config/initializers/wrap_parameters.rb：

# Convert json parameters, sent from Javascript UI, from camelCase to snake_case.
# This bridges the gap between javascript and ruby naming conventions.
module ActionController
  module ParamsNormalizer
    extend ActiveSupport::Concern

    def process_action(*args)
      deep_underscore_params!(request.parameters)
      super
    end

    private
      def deep_underscore_params!(val)
        case val
        when Array
          val.map {|v| deep_underscore_params! v }
        when Hash
          val.keys.each do |k, v = val[k]|
            val.delete k
            val[k.underscore] = deep_underscore_params!(v)
          end
          val
        else
          val
        end
      end
  end
end

# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
ActiveSupport.on_load(:action_controller) do
  wrap_parameters format: [:json] if respond_to?(:wrap_parameters)
  # Include the above defined concern
  include ::ActionController::ParamsNormalizer
end

Answer 4

在rails控制台中使用 camelCase到snake_case 的示例

2.3.1 :001 > params = ActionController::Parameters.new({"firstName"=>"john", "lastName"=>"doe", "email"=>"john@doe.com"})
=> <ActionController::Parameters {"firstName"=>"john", "lastName"=>"doe", "email"=>"john@doe.com"} permitted: false>

2.3.1 :002 > params.transform_keys(&:underscore)
=> <ActionController::Parameters {"first_name"=>"john", "last_name"=>"doe", "email"=>"john@doe.com"} permitted: false>

源：

http://api.rubyonrails.org/classes/ActionController/Parameters.html#method-i-transform_keys http://apidock.com/rails/String/underscore

Answer 5

解决 Rails 5

before_action :underscore_params!

def underscore_params!
  underscore_hash = -> (hash) do
    hash.transform_keys!(&:underscore)
    hash.each do |key, value|
      if value.is_a?(ActionController::Parameters)
        underscore_hash.call(value)
      elsif value.is_a?(Array)
        value.each do |item|
          next unless item.is_a?(ActionController::Parameters)
          underscore_hash.call(item)
        end
      end
    end
  end
  underscore_hash.call(params)
end

Answer 6

我想使用Chris Healds版本，但由于我使用的是Rails 4，因此我启用了strong_parameters，因此我不得不将其更改一段时间。

这是我提出的版本：

before_filter :deep_underscore_params!


def deep_underscore_params!(val = request.parameters)
  case val
  when Array
    val.map { |v| deep_underscore_params!(v) }
  when Hash
    val.keys.each do |k, v = val[k]|
      val.delete k
      val[k.underscore] = deep_underscore_params!(v)
    end

    params = val
  else
    val
  end
end

Answer 7

另一个轨道5.1解决方案，它背靠上面的Sebastian Hoitz解决方案。为了澄清我们为什么需要这样做：在R5.1中deep_transform_keys！不再是我们可用的方法，因为params不再继承自HashWithIndifferentAccess。并克服了Eliot Sykes提到的问题，其中初始化程序仅适用于application / json mime类型。它确实增加了所有请求的开销。（我很想看到ActionDispatch::Request.parameter_parsers[:multipart_form]）的一些初始化器，因为初始化器是一个更好的地方，IMO。

before_action :normalize_key!

 def normalize_keys!(val = params)
  if val.class == Array
    val.map { |v| normalize_keys! v }
  else
    if val.respond_to?(:keys)
      val.keys.each do |k|
        current_key_value = val[k]
        val.delete k
        val[k.to_s.underscore] = normalize_keys!(current_key_value)
      end
    end
    val
  end
  val
end

Answer 8

我们正在将我们的Rails API JSON密钥从snake_case转换为camelCase。我们必须逐步进行转换，即一些API使用snake_case，而其他API更改为使用camelCase。

我们的解决方案是我们

创建方法ActionController::Parameters#deep_snakeize
创建方法ApplicationController#snakeize_params
仅为使用camelCase密钥处理传入请求的控制器操作设置before_action :snakeize_params

您可以尝试vochicong/rails-json-api获取完整的Rails应用示例。

# File: config/initializers/params_snakeizer.rb
# Transform JSON request param keys from JSON-conventional camelCase to
# Rails-conventional snake_case
module ActionController
  # Modified from action_controller/metal/strong_parameters.rb
  class Parameters
    def deep_snakeize!
      @parameters.deep_transform_keys!(&:underscore)
      self
    end
  end
end

# File: app/controllers/application_controller.rb
class ApplicationController < ActionController::API
  protected

    # Snakeize JSON API request params
    def snakeize_params
      params.deep_snakeize!
    end
end

class UsersController < ApplicationController
  before_action :snakeize_params, only: [:create]

  # POST /users
  def create
    @user = User.new(user_params)

    if @user.save
      render :show, status: :created, location: @user
    else
      render json: @user.errors, status: :unprocessable_entity
    end
  end
end

Answer 9

路轨6 为deep_transform_keys添加了ActionController::Parameters，使您可以像这样简单：

class ApplicationController < ActionController::Base
  before_action :underscore_params!

  private

  def underscore_params!
    params.deep_transform_keys!(&:underscore)
  end
end

Answer 10

您可以创建在任何控制器调用之前运行的过滤器，并对其应用以下说明：

# transform camel case string into snake case
snake_string  = Proc.new {|s| s.gsub(/([a-z])([A-Z])/) {|t| "#{$1}_#{$2.downcase}"}} 

# transform all hash keys into snake case
snake_hash    = Proc.new do |hash| 
  hash.inject({}) do |memo, item|
    key, value = item

    key = case key
          when String
            snake_string.call(key)
          when Symbol
            snake_string.call(key.to_s).to_sym
          else 
            key
          end    

    memo[key] = value.instance_of?(Hash) ? snake_hash.call(value) : value
    memo
  end
end

params = snake_hash.call(params)

您必须考虑上述过程将对每个Rails调用施加一个小开销。

我不相信这是必要的，只要符合惯例。

Answer 11

在Rails 3中，tlewin的回答并没有给我带来帮助。看起来这些＃params＆＃39; =运算符将对其进行的未来操作无效。很奇怪。无论如何，以下工作对我来说，因为它只使用[] =和删除操作符：

before_filter :underscore_param_keys
def underscore_param_keys
  snake_hash = ->(hash) {
    # copying the hash for iteration so we are not altering and iterating over the same object
    hash.to_a.each do |key, value|
      hash.delete key
      hash[key.to_s.underscore] = value
      snake_hash.call(value) if value.is_a? Hash
      value.each { |item| snake_hash.call(item) if item.is_a? Hash } if value.is_a? Array
    end
  }
  snake_hash.call(params)
end

Answer 12

您可以尝试以下操作：

class ApplicationController < ActionController::API
  include ControllerHelper
  before_action :deep_underscore_params!

  def deep_underscore_params!(app_params = params)
    app_params.transform_keys!(&:underscore)
    app_params.each do |key, value|
      deep_underscore_params!(value) if value.instance_of?(ActionController::Parameters)
    end
    app_params.reject! { |k, v| v.blank? }
  end
end

Answer 13

基于上面的Eliot Sykes的回答，我认为我们可以在Rails5案例中做得更好。我不喜欢完全覆盖该功能，因为该代码可能会更改。所以我建议使用函数组合：

# File: config/initializers/json_param_key_transform.rb
# Transform JSON request param keys from JSON-conventional camelCase to
# Rails-conventional snake_case:
ActionDispatch::Request.parameter_parsers[:json] = (
  # Compose the original parser with a transformation
  ActionDispatch::Request.parameter_parsers[:json] >>
    # Transform camelCase param keys to snake_case
    ->(data) {
      data.deep_transform_keys(&:underscore)
    }
)

Answer 14

在这里我不能直接使用其他建议，但这使我走上了正确的道路。

在Rails 5.2中，使用版本化的API，因此无法在整个应用程序中对其进行更改。我创建了这个问题，然后将其包含在新api版本模块的基本控制器中。

module UnderscoreizeParams
  extend ActiveSupport::Concern

  def process_action(*args)
    request.parameters.deep_transform_keys!(&:underscore)
    super
  end
end

然后在我的API V3 BaseController中

class V3::BaseController
  include UnderscoreizeParams
end

享受。

在Rails中将所有控制器参数从camelCase转换为snake_case的最佳方法是什么？

14 个答案:

仅适用于Rails 5

对于Rails 4.2（可能是早期版本）

所有Rails版本的最后一步