Action Controller Parameters

返回一个新的 ActionController::Parameters 实例。此外，将 permitted 属性设置为 ActionController::Parameters.permit_all_parameters 的默认值。

class Person < ActiveRecord::Base
end

params = ActionController::Parameters.new(name: "Francesco")
params.permitted?  # => false
Person.new(params) # => ActiveModel::ForbiddenAttributesError

ActionController::Parameters.permit_all_parameters = true

params = ActionController::Parameters.new(name: "Francesco")
params.permitted?  # => true
Person.new(params) # => #<Person id: nil, name: "Francesco">

如果另一个 Parameters 对象包含相同的内容和允许标志，则返回 true。

返回给定 key 的参数。如果未找到，则返回 nil。

params = ActionController::Parameters.new(person: { name: "Francesco" })
params[:person] # => #<ActionController::Parameters {"name"=>"Francesco"} permitted: false>
params[:none]   # => nil

为给定的 key 分配一个值。当调用 permit 时，给定的键可能仍然被过滤掉。

返回一个哈希，可以用作参数的 JSON 表示。

返回一个新的 ActionController::Parameters 实例，其中去除了 nil 值。

就地移除所有 nil 值，并返回 self，如果未进行任何更改，则返回 nil。

返回一个新的 ActionController::Parameters 实例，其中去除了空白值。使用 Object#blank? 来确定一个值是否为空。

就地移除所有空白值，并返回 self。使用 Object#blank? 来确定一个值是否为空。

属性，跟踪已转换的数组（如果有），以避免在常见的 permit + 批量赋值用例中进行双重循环。在方法中定义，以便仅在需要时实例化它。

Testing 成员资格仍然会循环，但它比我们自己的转换值的循环更快。此外，我们不会为每个获取构建一个新的数组对象。

返回一个具有相同允许参数的 ActionController::Parameters 实例的副本。

返回一个新的 ActionController::Parameters 实例，其中递归地合并了 self 和 other_hash。

与标准库中的 Hash#merge 一样，可以提供一个块来合并值。

与 #deep_merge 相同，但会修改 self。

返回一个新的 ActionController::Parameters 实例，其中包含对每个键运行 block 的结果。这包括来自根哈希和来自所有嵌套哈希和数组的键。值保持不变。

返回具有更改键的相同 ActionController::Parameters 实例。这包括来自根哈希和来自所有嵌套哈希和数组的键。值保持不变。

从 Parameters 中删除一个键值对并返回其值。如果找不到 key，则返回 nil（或者，使用可选的代码块，则会生成 key 并返回结果）。此方法类似于 extract!，它返回相应的 ActionController::Parameters 对象。

通过在每个步骤调用 dig 从给定的 keys 中提取嵌套参数。如果任何中间步骤为 nil，则返回 nil。

params = ActionController::Parameters.new(foo: { bar: { baz: 1 } })
params.dig(:foo, :bar, :baz) # => 1
params.dig(:foo, :zot, :xyz) # => nil

params2 = ActionController::Parameters.new(foo: [10, 11, 12])
params2.dig(:foo, 1) # => 11

为参数中的每个键调用块一次，传递键。如果没有给出块，则返回枚举器。

将值中的所有哈希转换为参数，然后以与 Hash#each_pair 相同的方式生成每个对。

将值中的所有哈希转换为参数，然后以与 Hash#each_value 相同的方式生成每个值。

如果参数没有键值对，则返回 true。

返回一个新的 ActionController::Parameters 实例，该实例过滤掉给定的 keys。

params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.except(:a, :b) # => #<ActionController::Parameters {"c"=>3} permitted: false>
params.except(:d)     # => #<ActionController::Parameters {"a"=>1, "b"=>2, "c"=>3} permitted: false>

如果给定的键不存在于参数中，则返回 true。

expect 是要求和允许参数的首选方法。它比以前建议的按顺序调用 permit 和 require 更安全，这可能会导致用户触发的 500 错误。

expect 对类型更加严格，以避免使用 .require.permit 模式可能遇到的许多潜在陷阱。

例如

params = ActionController::Parameters.new(comment: { text: "hello" })
params.expect(comment: [:text])
# => #<ActionController::Parameters { text: "hello" } permitted: true>

params = ActionController::Parameters.new(comment: [{ text: "hello" }, { text: "world" }])
params.expect(comment: [:text])
# => ActionController::ParameterMissing: param is missing or the value is empty or invalid: comment

为了允许参数数组，必须显式定义数组。使用双方括号，即数组内嵌数组，来声明期望参数数组。

params = ActionController::Parameters.new(comments: [{ text: "hello" }, { text: "world" }])
params.expect(comments: [[:text]])
# => [#<ActionController::Parameters { "text" => "hello" } permitted: true>,
#     #<ActionController::Parameters { "text" => "world" } permitted: true>]

params = ActionController::Parameters.new(comments: { text: "hello" })
params.expect(comments: [[:text]])
# => ActionController::ParameterMissing: param is missing or the value is empty or invalid: comments

expect 用于防止数组篡改。

params = ActionController::Parameters.new(user: "hack")
# The previous way of requiring and permitting parameters will error
params.require(:user).permit(:name, pets: [:name]) # wrong
# => NoMethodError: undefined method `permit' for an instance of String

# similarly with nested parameters
params = ActionController::Parameters.new(user: { name: "Martin", pets: { name: "hack" } })
user_params = params.require(:user).permit(:name, pets: [:name]) # wrong
# user_params[:pets] is expected to be an array but is a hash

expect 通过对类型更加严格来解决此问题。

params = ActionController::Parameters.new(user: "hack")
params.expect(user: [ :name, pets: [[:name]] ])
# => ActionController::ParameterMissing: param is missing or the value is empty or invalid: user

# with nested parameters
params = ActionController::Parameters.new(user: { name: "Martin", pets: { name: "hack" } })
user_params = params.expect(user: [:name, pets: [[:name]] ])
user_params[:pets] # => nil

如示例所示，expect 需要 :user 键，以及类似于 .require.permit 模式的任何根键。如果期望多个根键，则它们都将被要求。

params = ActionController::Parameters.new(name: “Martin”, pies: [{ type: “dessert”, flavor: “pumpkin”}]) name, pies = params.expect(:name, pies: [[:type, :flavor]]) name # => “Martin” pies # => [#<ActionController::Parameters {“type”=>“dessert”, “flavor”=>“pumpkin”} permitted: true>]

当使用具有多个键的哈希调用时，expect 将允许参数并按在哈希中给出的顺序要求键，返回允许参数的数组。

params = ActionController::Parameters.new(subject: { name: “Martin” }, object: { pie: “pumpkin” }) subject, object = params.expect(subject: [:name], object: [:pie]) subject # =>

除了对数组与哈希参数更加严格之外，expect 在内部使用 permit，因此它的行为将类似。

params = ActionController::Parameters.new({
  person: {
    name: "Francesco",
    age:  22,
    pets: [{
      name: "Purplish",
      category: "dogs"
    }]
  }
})

permitted = params.expect(person: [ :name, { pets: [[:name]] } ])
permitted.permitted?           # => true
permitted[:name]               # => "Francesco"
permitted[:age]                # => nil
permitted[:pets][0][:name]     # => "Purplish"
permitted[:pets][0][:category] # => nil

可以使用以下方法期望允许标量数组

params = ActionController::Parameters.new(tags: ["rails", "parameters"])
permitted = params.expect(tags: [])
permitted.permitted?      # => true
permitted.is_a?(Array)    # => true
permitted.size            # => 2

与 expect 相同，但会引发 ActionController::ExpectedParameterMissing 而不是 ActionController::ParameterMissing。与会渲染 400 响应的 expect 不同，expect! 会引发未处理的异常。这旨在用于调试内部 API 的无效参数，其中格式不正确的参数将表明客户端库中的错误，该错误应予以修复。

删除并返回与给定键匹配的键值对。

params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.extract!(:a, :b) # => #<ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
params                  # => #<ActionController::Parameters {"c"=>3} permitted: false>

返回由 delimiter 分隔的给定 key 的参数值。

params = ActionController::Parameters.new(id: "1_123", tags: "ruby,rails")
params.extract_value(:id) # => ["1", "123"]
params.extract_value(:tags, delimiter: ",") # => ["ruby", "rails"]
params.extract_value(:non_existent_key) # => nil

请注意，如果给定的 key 的值包含空白元素，则返回的数组将包含空字符串。

params = ActionController::Parameters.new(tags: "ruby,rails,,web")
params.extract_value(:tags, delimiter: ",") # => ["ruby", "rails", "", "web"]

返回给定 key 的参数。如果找不到 key，则有几种选择：如果没有其他参数，它将引发 ActionController::ParameterMissing 错误；如果给出第二个参数，则返回该参数（如果可能，则转换为 ActionController::Parameters 的实例）；如果给出块，则将运行该块并返回其结果。

params = ActionController::Parameters.new(person: { name: "Francesco" })
params.fetch(:person)               # => #<ActionController::Parameters {"name"=>"Francesco"} permitted: false>
params.fetch(:none)                 # => ActionController::ParameterMissing: param is missing or the value is empty or invalid: none
params.fetch(:none, {})             # => #<ActionController::Parameters {} permitted: false>
params.fetch(:none, "Francesco")    # => "Francesco"
params.fetch(:none) { "Francesco" } # => "Francesco"

如果给定的值在参数中的某些键存在，则返回 true。

如果给定的键存在于参数中，则返回 true。

返回参数键的新数组。

返回一个新的 ActionController::Parameters 实例，其中包含从 other_hash 合并到当前哈希中的所有键。

返回当前的 ActionController::Parameters 实例，并将 other_hash 合并到当前的哈希中。

返回一个新的 ActionController::Parameters 实例，该实例仅包含给定的 filters，并将对象的 permitted 属性设置为 true。这对于限制哪些属性允许进行批量更新很有用。

params = ActionController::Parameters.new(name: "Francesco", age: 22, role: "admin")
permitted = params.permit(:name, :age)
permitted.permitted?      # => true
permitted.has_key?(:name) # => true
permitted.has_key?(:age)  # => true
permitted.has_key?(:role) # => false

只有允许的标量才能通过过滤器。例如，给定

params.permit(:name)

:name 如果它是 params 的一个键，其关联的值类型为 String、Symbol、NilClass、Numeric、TrueClass、FalseClass、Date、Time、DateTime、StringIO、IO、ActionDispatch::Http::UploadedFile 或 Rack::Test::UploadedFile，则可以通过过滤器。否则，键 :name 将被过滤掉。

您可以通过将其映射到空数组来声明该参数应该是允许标量的数组。

params = ActionController::Parameters.new(tags: ["rails", "parameters"])
params.permit(tags: [])

有时无法或不方便声明哈希参数的有效键或其内部结构。只需映射到空哈希即可。

params.permit(preferences: {})

请小心，因为这会打开任意输入的大门。在这种情况下，permit 确保返回结构中的值是允许的标量，并过滤掉其他任何内容。

您也可以对嵌套参数使用 permit。

params = ActionController::Parameters.new({
  person: {
    name: "Francesco",
    age:  22,
    pets: [{
      name: "Purplish",
      category: "dogs"
    }]
  }
})

permitted = params.permit(person: [ :name, { pets: :name } ])
permitted.permitted?                    # => true
permitted[:person][:name]               # => "Francesco"
permitted[:person][:age]                # => nil
permitted[:person][:pets][0][:name]     # => "Purplish"
permitted[:person][:pets][0][:category] # => nil

这还有助于拒绝发送字符串而不是哈希的用户的修改输入。

在 require 之后，您可以同时过滤和要求参数，遵循 Rails 表单的典型模式。expect 方法专门为这种情况而设计，是要求和允许参数的推荐方法。

 permitted = params.expect(person: [:name, :age])

在分别使用 permit 和 require 时，请注意方法调用的顺序。

 params = ActionController::Parameters.new(person: { name: "Martin", age: 40, role: "admin" })
 permitted = params.permit(person: [:name, :age]).require(:person) # correct

当首先使用 require 时，应用程序的用户可能会在用户（例如）为 :person 发送字符串时触发 NoMethodError。

 params = ActionController::Parameters.new(person: "tampered")
 permitted = params.require(:person).permit(:name, :age) # not recommended
 # => NoMethodError: undefined method `permit' for an instance of String

请注意，如果您在指向哈希的键中使用 permit，它将不会允许所有哈希。您还需要指定哈希中哪些属性应该被允许。

params = ActionController::Parameters.new({
  person: {
    contact: {
      email: "[email protected]",
      phone: "555-1234"
    }
  }
})

params.permit(person: :contact).require(:person)
# => #<ActionController::Parameters {} permitted: true>

params.permit(person: { contact: :phone }).require(:person)
# => #<ActionController::Parameters {"contact"=>#<ActionController::Parameters {"phone"=>"555-1234"} permitted: true>} permitted: true>

params.permit(person: { contact: [ :email, :phone ] }).require(:person)
# => #<ActionController::Parameters {"contact"=>#<ActionController::Parameters {"email"=>"[email protected]", "phone"=>"555-1234"} permitted: true>} permitted: true>

如果您的参数指定了多个由数字索引的参数，您可以使用与允许单个项目相同的语法来允许每个数字键下的参数集相同。

params = ActionController::Parameters.new({
  person: {
    '0': {
      email: "[email protected]",
      phone: "555-1234"
    },
    '1': {
      email: "[email protected]",
      phone: "555-6789"
    },
  }
})
params.permit(person: [:email]).to_h
# => {"person"=>{"0"=>{"email"=>"[email protected]"}, "1"=>{"email"=>"[email protected]"}}}

如果您想指定每个数字键想要哪些键，您可以改为分别指定每个键。

params = ActionController::Parameters.new({
  person: {
    '0': {
      email: "[email protected]",
      phone: "555-1234"
    },
    '1': {
      email: "[email protected]",
      phone: "555-6789"
    },
  }
})
params.permit(person: { '0': [:email], '1': [:phone]}).to_h
# => {"person"=>{"0"=>{"email"=>"[email protected]"}, "1"=>{"phone"=>"555-6789"}}}

将 permitted 属性设置为 true。这可用于传递批量赋值。返回 self。

class Person < ActiveRecord::Base
end

params = ActionController::Parameters.new(name: "Francesco")
params.permitted?  # => false
Person.new(params) # => ActiveModel::ForbiddenAttributesError
params.permit!
params.permitted?  # => true
Person.new(params) # => #<Person id: nil, name: "Francesco">

如果参数被允许，则返回 true，否则返回 false。

params = ActionController::Parameters.new
params.permitted? # => false
params.permit!
params.permitted? # => true

返回一个新的 ActionController::Parameters 实例，其中块评估为 true 的项已删除。

删除块评估为 true 的项，并返回 self。

此方法接受单个键和键数组。

当传递单个键时，如果它存在并且其关联的值存在或为单例 false，则返回该值。

ActionController::Parameters.new(person: { name: "Francesco" }).require(:person)
# => #<ActionController::Parameters {"name"=>"Francesco"} permitted: false>

否则，引发 ActionController::ParameterMissing

ActionController::Parameters.new.require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty or invalid: person

ActionController::Parameters.new(person: nil).require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty or invalid: person

ActionController::Parameters.new(person: "\t").require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty or invalid: person

ActionController::Parameters.new(person: {}).require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty or invalid: person

当给定一个键数组时，该方法尝试按顺序要求其中的每一个键。如果成功，则返回包含相应返回值的数组。

params = ActionController::Parameters.new(user: { ... }, profile: { ... })
user_params, profile_params = params.require([:user, :profile])

否则，该方法重新引发第一个找到的异常。

params = ActionController::Parameters.new(user: {}, profile: {})
user_params, profile_params = params.require([:user, :profile])
# ActionController::ParameterMissing: param is missing or the value is empty or invalid: user

此方法不推荐用于获取终端值，因为它不允许值。例如，这会导致问题。

# CAREFUL
params = ActionController::Parameters.new(person: { name: "Finn" })
name = params.require(:person).require(:name) # CAREFUL

建议使用 expect 代替。

def person_params
  # params.expect(person: :name).require(:name)
end

返回一个新的 ActionController::Parameters 实例，其中当前哈希中的所有键都合并到 other_hash 中。

返回当前的 ActionController::Parameters 实例，其中当前哈希合并到 other_hash 中。

返回一个新的 ActionController::Parameters 实例，其中仅包含块评估为 true 的项。

等效于 Hash#keep_if，但如果未进行任何更改，则返回 nil。

返回一个新的 ActionController::Parameters 实例，该实例仅包含给定的 keys。如果给定的 keys 不存在，则返回一个空哈希。

params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.slice(:a, :b) # => #<ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
params.slice(:d)     # => #<ActionController::Parameters {} permitted: false>

返回当前的 ActionController::Parameters 实例，该实例仅包含给定的 keys。

返回参数的安全 ActiveSupport::HashWithIndifferentAccess 表示形式，其中已删除所有未经允许的键。

params = ActionController::Parameters.new({
  name: "Senjougahara Hitagi",
  oddity: "Heavy stone crab"
})
params.to_h
# => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash

safe_params = params.permit(:name)
safe_params.to_h # => {"name"=>"Senjougahara Hitagi"}

返回参数的安全 Hash 表示形式，其中已删除所有未经允许的键。

params = ActionController::Parameters.new({
  name: "Senjougahara Hitagi",
  oddity: "Heavy stone crab"
})
params.to_hash
# => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash

safe_params = params.permit(:name)
safe_params.to_hash # => {"name"=>"Senjougahara Hitagi"}

返回接收者的字符串表示形式，适合用作 URL 查询字符串。

params = ActionController::Parameters.new({
  name: "David",
  nationality: "Danish"
})
params.to_query
# => ActionController::UnfilteredParameters: unable to convert unpermitted parameters to hash

safe_params = params.permit(:name, :nationality)
safe_params.to_query
# => "name=David&nationality=Danish"

可以传递一个可选的命名空间来包含键名。

params = ActionController::Parameters.new({
  name: "David",
  nationality: "Danish"
})
safe_params = params.permit(:name, :nationality)
safe_params.to_query("user")
# => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"

构成查询字符串的字符串对 "key=value" 按字母顺序排序。

以字符串形式返回参数的内容。

返回参数的不安全、未过滤的 ActiveSupport::HashWithIndifferentAccess 表示形式。

params = ActionController::Parameters.new({
  name: "Senjougahara Hitagi",
  oddity: "Heavy stone crab"
})
params.to_unsafe_h
# => {"name"=>"Senjougahara Hitagi", "oddity" => "Heavy stone crab"}

返回一个新的 ActionController::Parameters 实例，其中包含对每个键运行 block 的结果。值保持不变。

执行键转换并返回已更改的 ActionController::Parameters 实例。

返回一个新的 ActionController::Parameters 实例，其中包含对每个值运行 block 的结果。键保持不变。

params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.transform_values { |x| x * 2 }
# => #<ActionController::Parameters {"a"=>2, "b"=>4, "c"=>6} permitted: false>

执行值转换并返回已更改的 ActionController::Parameters 实例。

返回一个包含参数值的新的数组。

返回分配给给定 keys 的值。请注意，所有 Hash 对象都将转换为 ActionController::Parameters。

过滤自身，并可选地检查未经许可的键