Ruby on Rails 5.2 - ActionController::Parameters

क्लास एक्शनकंट्रोलर :: पैरामीटर्स




ruby

क्लास एक्शनकंट्रोलर :: पैरामीटर्स

जनक:
Object

एक्शन कंट्रोलर पैरामीटर्स

आपको यह चुनने की अनुमति देता है कि बड़े पैमाने पर अद्यतन करने के लिए कौन सी विशेषताओं को श्वेतसूचीबद्ध किया जाना चाहिए और इस प्रकार गलती से उजागर होने से रोकना चाहिए जिसे उजागर नहीं किया जाना चाहिए। इस उद्देश्य के लिए दो तरीके प्रदान करता है: require और permit । पूर्व का उपयोग आवश्यकतानुसार मापदंडों को चिह्नित करने के लिए किया जाता है। उत्तरार्द्ध का उपयोग पैरामीटर को अनुमति के रूप में सेट करने के लिए किया जाता है और बड़े पैमाने पर अद्यतन के लिए कौन सी विशेषताओं को अनुमति दी जानी चाहिए।

params = ActionController::Parameters.new({
  person: {
    name: "Francesco",
    age:  22,
    role: "admin"
  }
})

permitted = params.require(:person).permit(:name, :age)
permitted            # => <ActionController::Parameters {"name"=>"Francesco", "age"=>22} permitted: true>
permitted.permitted? # => true

Person.first.update!(permitted)
# => #<Person id: 1, name: "Francesco", age: 22, role: "user">

यह दो विकल्प प्रदान करता है जो नए उदाहरणों के शीर्ष-स्तरीय व्यवहार को नियंत्रित करता है:

  • permit_all_parameters - यदि यह true , तो डिफ़ॉल्ट रूप से सभी मापदंडों की अनुमति होगी। चूक false

  • action_on_unpermitted_parameters - व्यवहार को नियंत्रित करने की अनुमति दें जब पैरामीटर जो स्पष्ट रूप से अनुमत नहीं हैं, वे पाए जाते हैं। मान केवल उन्हें फ़िल्टर करने के लिए false हो सकते हैं :log इसके अलावा, लकड़हारा पर एक संदेश लिखने के लिए :log ऑन करें, या :raise ActionController::UnpermittedParameters :raise के लिए ActionController::UnpermittedParameters अपवाद। डिफ़ॉल्ट मान है :log परीक्षण और विकास के वातावरण में :log , अन्यथा false

उदाहरण:

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

ActionController::Parameters.permit_all_parameters = true

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

params = ActionController::Parameters.new(a: "123", b: "456")
params.permit(:c)
# => <ActionController::Parameters {} permitted: true>

ActionController::Parameters.action_on_unpermitted_parameters = :raise

params = ActionController::Parameters.new(a: "123", b: "456")
params.permit(:c)
# => ActionController::UnpermittedParameters: found unpermitted keys: a, b

कृपया ध्यान दें कि ये विकल्प * धागा-सुरक्षित नहीं हैं *। बहु-थ्रेडेड वातावरण में उन्हें केवल एक बार बूट-टाइम पर सेट किया जाना चाहिए और रनटाइम पर कभी भी म्यूट नहीं किया जाना चाहिए।

आप ActionController::Parameters मान प्राप्त कर सकते हैं ActionController::Parameters :key या "key"

params = ActionController::Parameters.new(key: "value")
params[:key]  # => "value"
params["key"] # => "value"

स्थिरांक

EMPTY_ARRAY
EMPTY_HASH
PERMITTED_SCALAR_TYPES

यह अनुमत स्केलर प्रकारों की एक सफेद सूची है जिसमें XML और JSON अनुरोधों में समर्थित वाले शामिल हैं।

यह सूची विशेष रूप से सामान्य अनुरोधों को फ़िल्टर करने के लिए उपयोग की जाती है, String सामान्य मामले को जल्दी से शॉर्ट-सर्किट करने के लिए पहले तत्व के रूप में जाती है।

यदि आप इस संग्रह को संशोधित करते हैं, तो कृपया ऊपर दिए गए permit के API को अपडेट करें।

गुण

पैरामीटर [R]

पब्लिक क्लास के तरीके

नया (पैरामीटर = {}) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 235
def initialize(parameters = {})
  @parameters = parameters.with_indifferent_access
  @permitted = self.class.permit_all_parameters
end

ActionController::Parameters का नया उदाहरण देता है ActionController::Parameters । इसके अलावा, ActionController::Parameters.permit_all_parameters के डिफ़ॉल्ट मान ActionController::Parameters.permit_all_parameters लिए permitted विशेषता सेट करता है।

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">

सार्वजनिक प्रवृत्ति के तरीके

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 242
def ==(other)
  if other.respond_to?(:permitted?)
    permitted? == other.permitted? && parameters == other.parameters
  else
    @parameters == other
  end
end

यदि कोई अन्य Parameters ऑब्जेक्ट में समान सामग्री और अनुमत ध्वज है, तो यह सही है।

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 551
def [](key)
  convert_hashes_to_parameters(key, @parameters[key])
end

दिए गए key लिए एक पैरामीटर देता है। यदि नहीं मिला है, तो nil देता है।

params = ActionController::Parameters.new(person: { name: "Francesco" })
params[:person] # => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
params[:none]   # => nil
[] = (कुंजी, मान) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 557
def []=(key, value)
  @parameters[key] = value
end

किसी दिए गए key मान निर्दिष्ट key । जब permit कहा जाता है तो दी गई कुंजी अभी भी फ़िल्टर हो सकती है।

as_json (विकल्प = nil) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 136
    

एक हैश है कि मापदंडों के लिए JSON प्रतिनिधित्व के रूप में इस्तेमाल किया जा सकता है।

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 350
def converted_arrays
  @converted_arrays ||= Set.new
end

सामान्य उपयोग के मामले परमिट + मास-असाइनमेंट में डबल लूपिंग से बचने के लिए, परिवर्तित सरणियों का ट्रैक रखने पर, यदि कोई हो, तो योगदान करें। जरूरत पड़ने पर ही इसे तुरंत लगाने की विधि में परिभाषित किया गया।

परीक्षण सदस्यता अभी भी लूप है, लेकिन यह हमारे स्वयं के लूप की तुलना में अधिक तेज़ होने वाला है जो मूल्यों को परिवर्तित करता है। साथ ही, हम प्रति भ्रूण एक नई सरणी ऑब्जेक्ट बनाने नहीं जा रहे हैं।

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 790
def deep_dup
  self.class.new(@parameters.deep_dup).tap do |duplicate|
    duplicate.permitted = @permitted
  end
end

सभी मापदंडों सहित ऑब्जेक्ट की डुप्लिकेट लौटाता है।

हटाएँ (कुंजी, और ब्लॉक) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 683
def delete(key, &block)
  convert_value_to_parameters(@parameters.delete(key, &block))
end

Parameters से एक कुंजी-मूल्य जोड़ी हटाता है और मान लौटाता है। यदि key नहीं मिली है, तो nil (या, वैकल्पिक कोड ब्लॉक के साथ, key देता है और परिणाम देता है)। सी एफ #extract! , जो संबंधित ActionController::Parameters ऑब्जेक्ट देता है।

delete_if (और ब्लॉक)
इसके लिए उपनाम: reject!
खुदाई (* चाबियाँ) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 596
def dig(*keys)
  convert_hashes_to_parameters(keys.first, @parameters[keys.first])
  @parameters.dig(*keys)
end

प्रत्येक चरण में 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
प्रत्येक (और ब्लॉक)
इसके लिए उपनाम: each_pair
प्रत्येक_पेयर () {| कुंजी, Convert_hashes_to_parameters (कुंजी, मान) | ...} स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 336
def each_pair(&block)
  @parameters.each_pair do |key, value|
    yield [key, convert_hashes_to_parameters(key, value)]
  end
end

सभी हैश को मापदंडों में मानों में परिवर्तित करें, फिर प्रत्येक जोड़ी को उसी तरह पैदावार दें जैसे Hash#each_pair

इसके अलावा उपनाम: each
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 144
    

यदि पैरामीटर में कोई कुंजी / मान युग्म नहीं है, तो यह सही है।

को छोड़कर (* कुंजियाँ) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 626
def except(*keys)
  new_instance_with_inherited_permitted_status(@parameters.except(*keys))
end

एक नया ActionController::Parameters उदाहरण देता है जो दिए गए keys को फ़िल्टर 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>
निकालने! (* की) शो सोर्स
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 635
def extract!(*keys)
  new_instance_with_inherited_permitted_status(@parameters.extract!(*keys))
end

दिए गए कुंजी से मेल खाते कुंजी / मान जोड़े को निकालता है और वापस करता है।

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>
लाने (कुंजी, * आर्ग्स) {|| ...} स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 574
def fetch(key, *args)
  convert_value_to_parameters(
    @parameters.fetch(key) {
      if block_given?
        yield
      else
        args.fetch(0) { raise ActionController::ParameterMissing.new(key) }
      end
    }
  )
end

दिए गए key लिए एक पैरामीटर देता है। यदि key नहीं मिल सकती है, तो कई विकल्प हैं: कोई अन्य तर्क के साथ, यह ActionController::ParameterMissing त्रुटि करेगा; यदि दूसरा तर्क दिया जाता है, तो उसे वापस कर दिया जाता है ( ActionController::Parameters उदाहरण में बदल दिया जाता है ActionController::Parameters यदि संभव हो तो 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"
has_key? (कुंजी) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 152
    

यदि पैरामीटर में दी गई कुंजी मौजूद है तो सही है।

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 160
    

यदि पैरामीटर में कुछ कुंजी के लिए दिए गए मान मौजूद हैं, तो सही है।

शामिल हैं। (कुंजी) शो स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 168
    

यदि पैरामीटर में दी गई कुंजी मौजूद है तो सही है।

निरीक्षण () स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 758
def inspect
  "<#{self.class} #{@parameters} permitted: #{@permitted}>"
end
Keep_if (& block)
इसके लिए उपनाम: select!
कुंजी? (कुंजी) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 176
    

यदि पैरामीटर में दी गई कुंजी मौजूद है तो सही है।

चाबियाँ () स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 184
    

मापदंडों की कुंजी का एक नया सरणी देता है।

मर्ज (other_hash) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 721
def merge(other_hash)
  new_instance_with_inherited_permitted_status(
    @parameters.merge(other_hash.to_h)
  )
end

एक नया ActionController::Parameters से सभी कुंजियों वाले ActionController::Parameters को हैश में विलय कर दिया जाता है।

विलय! (other_hash) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 729
def merge!(other_hash)
  @parameters.merge!(other_hash.to_h)
  self
end

करंट ActionController::Parameters लौटाता है: ActionController::Parameters साथ ActionController::Parameters उदाहरण करंट हैश में विलीन हो जाता है।

अनुमति (* फ़िल्टर) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 528
def permit(*filters)
  params = self.class.new

  filters.flatten.each do |filter|
    case filter
    when Symbol, String
      permitted_scalar_filter(params, filter)
    when Hash
      hash_filter(params, filter)
    end
  end

  unpermitted_parameters!(params) if self.class.action_on_unpermitted_parameters

  params.permit!
end

एक नया ActionController::Parameters उदाहरण देता है जिसमें केवल दिए गए filters और ऑब्जेक्ट को true करने के लिए 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 गुजरता है अगर यह उन NilClass की एक कुंजी है, जिनका संबद्ध मूल्य 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

ध्यान दें कि यदि आप किसी हैश को इंगित करने वाली कुंजी में permit का उपयोग करते हैं, तो यह सभी हैश की अनुमति नहीं देगा। आपको यह भी निर्दिष्ट करने की आवश्यकता है कि हैश के अंदर कौन सी विशेषताओं को सफेद किया जाना चाहिए।

params = ActionController::Parameters.new({
  person: {
    contact: {
      email: "[email protected]",
      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"=>"[email protected]", "phone"=>"555-1234"} permitted: true>} permitted: true>
की अनुमति! () स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 376
def permit!
  each_pair do |key, value|
    Array.wrap(value).flatten.each do |v|
      v.permit! if v.respond_to? :permit!
    end
  end

  @permitted = true
  self
end

permitted विशेषता को true सेट करता 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">
अनुमति है? () स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 360
def permitted?
  @permitted
end

अगर पैरामीटर की अनुमति है, तो true है, अन्यथा false है।

params = ActionController::Parameters.new
params.permitted? # => false
params.permit!
params.permitted? # => true
अस्वीकार (और ब्लॉक) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 702
def reject(&block)
  new_instance_with_inherited_permitted_status(@parameters.reject(&block))
end

ActionController::Parameters का एक नया उदाहरण देता है ActionController::Parameters उन आइटमों के साथ जिन्हें ब्लॉक सही हटाए जाने का मूल्यांकन करता है।

अस्वीकार! (और ब्लॉक) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 707
def reject!(&block)
  @parameters.reject!(&block)
  self
end

उन वस्तुओं को हटाता है जो ब्लॉक सच का मूल्यांकन करता है और स्वयं को वापस लौटाता है।

इसके रूप में भी उपनाम: delete_if
आवश्यकता (कुंजी) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 437
def require(key)
  return key.map { |k| require(k) } if key.is_a?(Array)
  value = self[key]
  if value.present? || value == false
    value
  else
    raise ParameterMissing.new(key)
  end
end

यह विधि एकल कुंजी और कुंजियों की एक सरणी दोनों को स्वीकार करती है।

जब एक ही कुंजी पास की जाती है, यदि वह मौजूद है और उसका संबद्ध मूल्य या तो मौजूद है या सिंगलटन false , तो रिटर्न ने कहा मूल्य:

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

अन्यथा ActionController::ParameterMissing उठाता है 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

उदाहरण के लिए।

इसके अलावा उपनाम: required
आवश्यक (कुंजी)

require उपनाम।

के लिए उपनाम: require
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 736
def reverse_merge(other_hash)
  new_instance_with_inherited_permitted_status(
    other_hash.to_h.merge(@parameters)
  )
end

एक नया ActionController::Parameters वर्तमान हैश से सभी कुंजियों वाले ActionController::Parameters other_hash में विलय हो other_hash

के रूप में भी उपनाम: with_defaults
reverse_merge! (other_hash) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 745
def reverse_merge!(other_hash)
  @parameters.merge!(other_hash.to_h) { |key, left, right| left }
  self
end

वर्तमान ActionController::Parameters लौटाता है ActionController::Parameters वर्तमान हैश के साथ ActionController::Parameters उदाहरण other_hash में विलय हो other_hash

के रूप में भी उपनाम: with_defaults!
स्रोत का चयन करें (और ब्लॉक)
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 689
def select(&block)
  new_instance_with_inherited_permitted_status(@parameters.select(&block))
end

ActionController::Parameters का एक नया उदाहरण देता है ActionController::Parameters केवल उन आइटमों के साथ जो ब्लॉक सही का मूल्यांकन करता है।

चुनते हैं! (और ब्लॉक) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 694
def select!(&block)
  @parameters.select!(&block)
  self
end

हैश # Keep_if के समतुल्य, लेकिन यदि कोई परिवर्तन नहीं किया गया, तो रिटर्न nil

इसके अलावा उपनाम: keep_if
टुकड़ा (* कुंजियाँ) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 609
def slice(*keys)
  new_instance_with_inherited_permitted_status(@parameters.slice(*keys))
end

एक नया 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>
स्लाइस! (* की) शो सोर्स
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 615
def slice!(*keys)
  @parameters.slice!(*keys)
  self
end

वर्तमान ActionController::Parameters लौटाता है ActionController::Parameters उदाहरण जिसमें केवल दिए गए keys

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 262
def to_h
  if permitted?
    convert_parameters_to_hashes(@parameters, :to_h)
  else
    raise UnfilteredParameters
  end
end

एक सुरक्षित ActiveSupport::HashWithIndifferentAccess देता है ActiveSupport::HashWithIndifferentAccess सभी निष्कासित कुंजी के साथ मापदंडों का 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"}
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 282
def to_hash
  to_h.to_hash
end

हटाए गए सभी अप्रमाणित कुंजी के साथ मापदंडों का एक सुरक्षित 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"}
to_param (* args)
अन्य के लिए उपनाम: to_query
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 314
def to_query(*args)
  to_h.to_query(*args)
end

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"

क्वेरी स्ट्रिंग के अनुरूप स्ट्रिंग जोड़े "की = वैल्यू" को आरोही क्रम में लेक्सिकोग्राफिक रूप से सॉर्ट किया जाता है।

इस विधि to_param रूप में भी to_param किया to_param

इसके अलावा to_param : to_param
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 192
    

मापदंडों की सामग्री को एक स्ट्रिंग के रूप में लौटाता है।

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 329
def to_unsafe_h
  convert_parameters_to_hashes(@parameters, :to_unsafe_h)
end

एक असुरक्षित, अनफ़िल्टर्ड ActiveSupport::HashWithIndifferentAccess पैरामीटर का प्रतिनिधित्व करता है।

params = ActionController::Parameters.new({
  name: "Senjougahara Hitagi",
  oddity: "Heavy stone crab"
})
params.to_unsafe_h
# => {"name"=>"Senjougahara Hitagi", "oddity" => "Heavy stone crab"}
साथ ही: to_unsafe_hash
to_unsafe_hash ()
इसके लिए उपनाम: to_unsafe_h
transform_keys (& block) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 662
def transform_keys(&block)
  if block
    new_instance_with_inherited_permitted_status(
      @parameters.transform_keys(&block)
    )
  else
    @parameters.transform_keys
  end
end

एक नया ActionController::Parameters हर कुंजी के लिए एक बार रनिंग block के परिणामों के साथ ActionController::Parameters उदाहरण। मान अपरिवर्तित हैं।

transform_keys! (और ब्लॉक) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 674
def transform_keys!(&block)
  @parameters.transform_keys!(&block)
  self
end

कुंजियाँ परिवर्तित करता है और परिवर्तित ActionController::Parameters उदाहरण देता है।

transform_values () {| Convert_value_to_parameters (v) ...} स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 645
def transform_values
  return to_enum(:transform_values) unless block_given?
  new_instance_with_inherited_permitted_status(
    @parameters.transform_values { |v| yield convert_value_to_parameters(v) }
  )
end

एक नया ActionController::Parameters हर मान के लिए एक बार रनिंग block के परिणामों के साथ ActionController::Parameters । चाबियाँ अपरिवर्तित हैं।

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>
transform_values! () {| Convert_value_to_parameters (v) | ...} स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 654
def transform_values!
  return to_enum(:transform_values!) unless block_given?
  @parameters.transform_values! { |v| yield convert_value_to_parameters(v) }
  self
end

मान परिवर्तन करता है और परिवर्तित ActionController::Parameters उदाहरण देता है।

मूल्य। (मान) स्रोत दिखाएँ
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 200
    

यदि पैरामीटर में कुछ कुंजी के लिए दिए गए मान मौजूद हैं, तो सही है।

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 207
delegate :keys, :key?, :has_key?, :values, :has_value?, :value?, :empty?, :include?,
  :as_json, :to_s, to: :@parameters

मापदंडों के मूल्यों की एक नई सरणी देता है।

values_at (* कुंजियाँ) दिखाएँ स्रोत
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 715
def values_at(*keys)
  convert_value_to_parameters(@parameters.values_at(*keys))
end

उन मानों को लौटाता है जो दी गई keys को सौंपा गया था। ध्यान दें कि सभी Hash ऑब्जेक्ट को ActionController::Parameters बदल दिया जाएगा।

with_defaults (other_hash)
अन्य के लिए उपनाम: reverse_merge
with_defaults! (other_hash)
इसके लिए उपनाम: reverse_merge!

संरक्षित उदाहरण तरीके

# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 803
def fields_for_style?
  @parameters.all? { |k, v| k =~ /\A-?\d+\z/ && (v.is_a?(Hash) || v.is_a?(Parameters)) }
end
अनुमत = (new_permitted) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/strong_parameters.rb, line 799
def permitted=(new_permitted)
  @permitted = new_permitted
end