Action Controller 参数

返回一个新的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? 来确定一个值是否为空。

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

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

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

返回一个重复的 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。

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

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>

返回 key 的参数值，该值由 delimiter 分隔。

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) # => ["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: 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(user: { name: "Francesco", age: 22, role: "admin" })
permitted = params.require(:user).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 会通过。否则，将过滤掉键 :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

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

params = ActionController::Parameters.new({
  person: {
    contact: {
      email: "none@test.com",
      phone: "555-1234"
    }
  }
})

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

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

params.require(:person).permit(contact: [ :email, :phone ])
# => #<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 的项并返回自身。

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

当传递单个键时，如果该键存在且其关联值存在或为单例 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: person

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

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

ActionController::Parameters.new(person: {}).require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty: 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: user

从技术上讲，此方法可用于获取终端值

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

但请考虑在某些时候必须允许这些值

def person_params
  params.require(:person).permit(:name).tap do |person_params|
    person_params.require(:name) # SAFER
  end
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。