動作控制器 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 表示形式。

返回一個已移除 nil 值的新 ActionController::Parameters 實例。

移除所有 nil 值，並返回 self；如果沒有任何更改，則返回 nil。

傳回一個沒有空白值的新 `ActionController::Parameters` 實例。使用 `Object#blank?` 來判斷值是否為空白。

移除所有空白值並返回自身。使用 Object#blank? 來判斷值是否為空白。

追蹤已轉換陣列（如果有的話）的屬性，以避免在常見用例 permit + 批量賦值中重複循環。在方法中定義，以便僅在需要時才實例化它。

測試成員資格仍然會循環，但它比我們自己轉換值的循環更快。此外，我們不會為每次提取構建新的陣列對象。

返回具有相同允許參數的重複 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 將通過。否則，鍵 :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::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"=>"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 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。

過濾自身並選擇性地檢查未經允許的鍵