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? 来确定值是否为空。

属性，用于跟踪转换的数组，以避免在常见的 use case permit + mass-assignment 中进行双重循环。在方法中定义，仅在需要时实例化。

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 # => #<ActionController::Parameters {"name"=>"Martin"} permitted: true>
object  # => #<ActionController::Parameters {"pie"=>"pumpkin"} permitted: true>

除了对数组与哈希参数更严格之外，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                 # => ["rails", "parameters"]
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)

当其关联值为 String、Symbol、NilClass、Numeric、TrueClass、FalseClass、Date、Time、DateTime、StringIO、IO、ActionDispatch::Http::UploadedFile 或 Rack::Test::UploadedFile 类型时，:name 通过。否则，键 :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: "none@test.com",
      phone: "555-1234"
    }
  }
})

params.permit(person: :contact).require(:person)
# => ActionController::ParameterMissing: param is missing or the value is empty or invalid: person

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"=>"none@test.com", "phone"=>"555-1234"} permitted: true>} permitted: true>

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

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

如果您想指定要从每个数字键中获取的键，您可以改为单独指定每个键

params = ActionController::Parameters.new({
  person: {
    '0': {
      email: "none@test.com",
      phone: "555-1234"
    },
    '1': {
      email: "nothing@test.com",
      phone: "555-6789"
    },
  }
})
params.permit(person: { '0': [:email], '1': [:phone]}).to_h
# => {"person"=>{"0"=>{"email"=>"none@test.com"}, "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。

过滤 self，并可选地检查未允许的键