Ruby on Rails 5.2 - ActionView::Helpers::FormHelper

मॉड्यूल एक्शन व्यू :: हेल्पर्स :: फॉर्म हेल्पर




ruby

मॉड्यूल एक्शन व्यू :: हेल्पर्स :: फॉर्म हेल्पर

शामिल मॉड्यूल:
ActionView::Helpers::FormTagHelper , ActionView::Helpers::UrlHelper ActionView::RecordIdentifier , ActionView::RecordIdentifier

फॉर्म हेल्पर्स को वेनिला एचटीएमएल का उपयोग करने की तुलना में संसाधनों के साथ काम करने के लिए बहुत आसान बनाया गया है।

आमतौर पर, किसी संसाधन को बनाने या अपडेट करने के लिए डिज़ाइन किया गया फ़ॉर्म संसाधन की पहचान को कई तरीकों से दर्शाता है: (i) वह URL जिसे फ़ॉर्म भेजा जाता है (प्रपत्र तत्व की action विशेषता) को एक अनुरोध में परिणामित किया जाना चाहिए जो उचित नियंत्रक को रूट किया जाए कार्रवाई (उपयुक्त के साथ :id एक मौजूदा संसाधन के मामले में :id पैरामीटर), (ii) इनपुट फ़ील्ड को इस तरह नामित किया जाना चाहिए कि नियंत्रक में उनके मान उचित स्थानों पर params हैश के भीतर दिखाई दें, और (iii) के लिए एक मौजूदा रिकॉर्ड, जब फॉर्म को शुरू में प्रदर्शित किया जाता है, तो संसाधन की विशेषताओं के अनुरूप इनपुट फ़ील्ड को उन विशेषताओं के वर्तमान मूल्यों को दिखाना चाहिए।

रेल में, यह आमतौर पर form_for और संबंधित सहायक विधियों की संख्या का उपयोग करके फ़ॉर्म को बनाकर प्राप्त किया जाता है। form_for एक उपयुक्त form टैग form और एक फॉर्म बिल्डर ऑब्जेक्ट प्राप्त करता है जो मॉडल के बारे में जानता है कि फॉर्म किस बारे में है। इनपुट फ़ील्ड फॉर्म बिल्डर पर परिभाषित तरीकों को कॉल करके बनाए जाते हैं, जिसका अर्थ है कि वे मॉडल विशेषताओं के अनुरूप उपयुक्त नाम और डिफ़ॉल्ट मान उत्पन्न करने में सक्षम हैं, साथ ही सुविधाजनक आईडी आदि। उत्पन्न फ़ील्ड नामों में कन्वर्टर नियंत्रकों को प्राप्त करने की अनुमति देते हैं। अपनी तरफ से कोई प्रयास किए बिना डेटा को संरचित रूप से params में params

उदाहरण के लिए, एक नया व्यक्ति बनाने के लिए जिसे आप आमतौर पर PeopleController#new कार्रवाई, @person में Person का एक नया उदाहरण सेट @person , और व्यू टेम्प्लेट में उस ऑब्जेक्ट को form_for पास करते हैं:

<%= form_for @person do |f| %>
  <%= f.label :first_name %>:
  <%= f.text_field :first_name %><br />

  <%= f.label :last_name %>:
  <%= f.text_field :last_name %><br />

  <%= f.submit %>
<% end %>

इस के लिए उत्पन्न HTML (मापांक प्रारूपण) होगा:

<form action="/people" class="new_person" id="new_person" method="post">
  <input name="authenticity_token" type="hidden" value="NrOp5bsjoLRuK8IW5+dQEYjKGUJDe7TQoZVvq95Wteg=" />
  <label for="person_first_name">First name</label>:
  <input id="person_first_name" name="person[first_name]" type="text" /><br />

  <label for="person_last_name">Last name</label>:
  <input id="person_last_name" name="person[last_name]" type="text" /><br />

  <input name="commit" type="submit" value="Create Person" />
</form>

जैसा कि आप देखते हैं, HTML कई स्थानों में संसाधन के बारे में ज्ञान को दर्शाता है, जैसे कि पथ को फॉर्म सबमिट किया जाना चाहिए, या इनपुट फ़ील्ड के नाम।

विशेष रूप से, उत्पन्न फ़ील्ड नामों में अनुसरण किए जाने वाले सम्मेलनों के लिए, नियंत्रक को एक नेस्टेड हैश params[:person] के रूप में निर्धारित व्यक्ति विशेषताओं के साथ मिलता है। उस हैश को Person.new को पारित करने के लिए तैयार है:

@person = Person.new(params[:person])
if @person.save
  # success
else
  # error handling
end

दिलचस्प है, पिछले उदाहरण में सटीक समान दृश्य कोड का उपयोग किसी व्यक्ति को संपादित करने के लिए किया जा सकता है। अगर @person "जॉन स्मिथ" और ID 256 के नाम से एक मौजूदा रिकॉर्ड है, तो इसके बजाय ऊपर दिए गए कोड के अनुसार उपज होगी:

<form action="/people/256" class="edit_person" id="edit_person_256" method="post">
  <input name="_method" type="hidden" value="patch" />
  <input name="authenticity_token" type="hidden" value="NrOp5bsjoLRuK8IW5+dQEYjKGUJDe7TQoZVvq95Wteg=" />
  <label for="person_first_name">First name</label>:
  <input id="person_first_name" name="person[first_name]" type="text" value="John" /><br />

  <label for="person_last_name">Last name</label>:
  <input id="person_last_name" name="person[last_name]" type="text" value="Smith" /><br />

  <input name="commit" type="submit" value="Update Person" />
</form>

ध्यान दें कि समापन बिंदु, डिफ़ॉल्ट मान और सबमिट बटन लेबल @person लिए @person । यह उस तरह से काम करता है क्योंकि शामिल सहायकों को पता है कि संसाधन एक नया रिकॉर्ड है या नहीं, और तदनुसार HTML उत्पन्न करता है।

नियंत्रक को प्रपत्र डेटा फिर से params[:person] में प्राप्त होगा params[:person] , Person#update करने के लिए तैयार होने के लिए:

if @person.update(params[:person])
  # success
else
  # error handling
end

आप आमतौर पर संसाधनों के साथ काम करते हैं।

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

check_box (object_name, विधि, विकल्प = {}, check_value = "1", अनियंत्रित_वायु = "0") स्रोत दिखाएँ
# File actionview/lib/action_view/helpers/form_helper.rb, line 1294
def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
  Tags::CheckBox.new(object_name, method, self, checked_value, unchecked_value, options).render
end

एक निर्दिष्ट विशेषता ( method द्वारा पहचानी गई) तक पहुँच के लिए एक चेकबॉक्स टैग लौटाता है जो टेम्पलेट को सौंपी गई object ( object द्वारा पहचाना गया) पर होता है। यह ऑब्जेक्ट एक इंस्टेंस ऑब्जेक्ट (@object) होना चाहिए न कि स्थानीय ऑब्जेक्ट। यह इरादा है कि method एक पूर्णांक लौटाती है और यदि वह पूर्णांक शून्य से ऊपर है, तो चेकबॉक्स की जाँच की जाती है। इनपुट टैग पर अतिरिक्त विकल्पों को options साथ हैश के रूप में पारित किया जा सकता है। checked_value 1 से जबकि डिफ़ॉल्ट unchecked_value 0 पर सेट है जो बूलियन मान के लिए सुविधाजनक है।

पकड़ लिया

HTML विनिर्देशन का कहना है कि अनियंत्रित चेक बॉक्स सफल नहीं हैं, और इस तरह वेब ब्राउज़र उन्हें नहीं भेजते हैं। दुर्भाग्य से यह एक गोचर का परिचय देता है: यदि किसी Invoice मॉडल में एक paid झंडा होता है, और भुगतान किए गए चालान को संपादित करने वाले रूप में उपयोगकर्ता अपने चेक बॉक्स को अनचेक करता है, तो कोई paid पैरामीटर नहीं भेजा जाता है। तो, किसी भी मास-असाइनमेंट मुहावरे की तरह

@invoice.update(params[:invoice])

ध्वज को अपडेट नहीं किया जाएगा।

इसे रोकने के लिए सहायक बहुत ही चेक बॉक्स से पहले एक सहायक छिपा क्षेत्र उत्पन्न करता है। छिपे हुए फ़ील्ड का नाम समान है और इसकी विशेषताएँ एक अनियंत्रित चेक बॉक्स की नकल करती हैं।

इस तरह, क्लाइंट या तो केवल छिपे हुए फ़ील्ड को भेजता है (चेक बॉक्स का प्रतिनिधित्व अनियंत्रित है), या दोनों फ़ील्ड। चूंकि HTML विनिर्देश कहता है कि कुंजी / मान जोड़े को उसी क्रम में भेजा जाना है जो वे फॉर्म में दिखाई देते हैं, और पैरामीटर निष्कर्षण को क्वेरी स्ट्रिंग में किसी भी दोहराया कुंजी की अंतिम घटना मिलती है, जो सामान्य रूपों के लिए काम करती है।

दुर्भाग्यवश, जब चेक बॉक्स किसी सरणी-जैसा पैरामीटर के भीतर जाता है, तब काम नहीं करता

<%= fields_for "project[invoice_attributes][]", invoice, index: nil do |form| %>
  <%= form.check_box :paid %>
  ...
<% end %>

क्योंकि पैरामीटर नाम पुनरावृत्ति ठीक वही है जो रेल सरणी के तत्वों को अलग करना चाहता है। एक चेक किए गए चेक बॉक्स के साथ प्रत्येक आइटम के लिए आपको केवल "विशेषता" के लिए असाइन किया गया एक अतिरिक्त भूत आइटम मिलता है।

उस स्थिति में या तो check_box_tag उपयोग check_box_tag या सरणियों के बजाय हैश का उपयोग करना बेहतर होता है।

# Let's say that @post.validated? is 1:
check_box("post", "validated")
# => <input name="post[validated]" type="hidden" value="0" />
#    <input checked="checked" type="checkbox" id="post_validated" name="post[validated]" value="1" />

# Let's say that @puppy.gooddog is "no":
check_box("puppy", "gooddog", {}, "yes", "no")
# => <input name="puppy[gooddog]" type="hidden" value="no" />
#    <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />

check_box("eula", "accepted", { class: 'eula_check' }, "yes", "no")
# => <input name="eula[accepted]" type="hidden" value="no" />
#    <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
color_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1324
def color_field(object_name, method, options = {})
  Tags::ColorField.new(object_name, method, self, options).render
end

"रंग" प्रकार का #text_field लौटाता है।

color_field("car", "color")
# => <input id="car_color" name="car[color]" type="color" value="#000000" />
date_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1388
def date_field(object_name, method, options = {})
  Tags::DateField.new(object_name, method, self, options).render
end

"दिनांक" प्रकार का एक #text_field लौटाता है।

date_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="date" />

डिफ़ॉल्ट मान ऑब्जेक्ट के मान पर "% Y-% m-% d" के साथ strftime को कॉल करने की कोशिश करके उत्पन्न होता है, जो इसे DateTime और ActiveSupport::TimeWithZone उदाहरण के लिए अपेक्षित रूप से व्यवहार करता है ActiveSupport::TimeWithZone । आप अभी भी "मान" विकल्प को स्पष्ट रूप से पारित करके ओवरराइड कर सकते हैं, जैसे

@user.born_on = Date.new(1984, 1, 27)
date_field("user", "born_on", value: "1984-05-12")
# => <input id="user_born_on" name="user[born_on]" type="date" value="1984-05-12" />

आप Date और Time उदाहरणों को पास करके "मिनट" और "अधिकतम" विशेषताओं के लिए मान बना सकते हैं।

date_field("user", "born_on", min: Date.today)
# => <input id="user_born_on" name="user[born_on]" type="date" min="2014-05-20" />

वैकल्पिक रूप से, आप "मिनट" और "अधिकतम" के मूल्यों के रूप में ISO8601 तिथि के रूप में एक String स्वरूपित पास कर सकते हैं।

date_field("user", "born_on", min: "2014-05-20")
# => <input id="user_born_on" name="user[born_on]" type="date" min="2014-05-20" />
datetime_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1446
def datetime_field(object_name, method, options = {})
  Tags::DatetimeLocalField.new(object_name, method, self, options).render
end

" #text_field -लोकल" प्रकार का एक #text_field लौटाता है।

datetime_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="datetime-local" />

डिफ़ॉल्ट मान ऑब्जेक्ट के मान पर "% Y-% m-% dT% T" के साथ कॉल करने का प्रयास करने से उत्पन्न होता है, जो इसे DateTime और ActiveSupport::TimeWithZone उदाहरणों के लिए अपेक्षित व्यवहार करता है ActiveSupport::TimeWithZone

@user.born_on = Date.new(1984, 1, 12)
datetime_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="datetime-local" value="1984-01-12T00:00:00" />

आप Date और Time उदाहरणों को पास करके "मिनट" और "अधिकतम" विशेषताओं के लिए मान बना सकते हैं।

datetime_field("user", "born_on", min: Date.today)
# => <input id="user_born_on" name="user[born_on]" type="datetime-local" min="2014-05-20T00:00:00.000" />

वैकल्पिक रूप से, आप "मिनट" और "अधिकतम" के मूल्यों के रूप में ISO8601 डेटाटाइम के रूप में एक String को पास कर सकते हैं।

datetime_field("user", "born_on", min: "2014-05-20T00:00:00")
# => <input id="user_born_on" name="user[born_on]" type="datetime-local" min="2014-05-20T00:00:00.000" />
इसके रूप में भी उपनाम: datetime_local_field
datetime_local_field (object_name, विधि, विकल्प = {})
इसके लिए उपनाम: datetime_field
email_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1500
def email_field(object_name, method, options = {})
  Tags::EmailField.new(object_name, method, self, options).render
end

"ईमेल" प्रकार का #text_field लौटाता है।

email_field("user", "address")
# => <input id="user_address" name="user[address]" type="email" />
फ़ील्ड्स (स्कोप = nil, मॉडल: nil, ** ऑप्शंस, और ब्लॉक) शो सोर्स
# File actionview/lib/action_view/helpers/form_helper.rb, line 1054
def fields(scope = nil, model: nil, **options, &block)
  options[:allow_method_names_outside_object] = true
  options[:skip_default_ids] = !form_with_generates_ids

  if model
    scope ||= model_name_from_record_or_class(model).param_key
  end

  builder = instantiate_builder(scope, model, options)
  capture(builder, &block)
end

स्कोप्स इनपुट फ़ील्ड या तो एक स्पष्ट दायरे या मॉडल के साथ। जैसे form_with करता है :scope या :model , सिवाय इसके कि यह फॉर्म टैग को आउटपुट नहीं करता है।

# Using a scope prefixes the input field names:
<%= fields :comment do |fields| %>
  <%= fields.text_field :body %>
<% end %>
# => <input type="text" name="comment[body]">

# Using a model infers the scope and assigns field values:
<%= fields model: Comment.new(body: "full bodied") do |fields| %>
  <%= fields.text_field :body %>
<% end %>
# => <input type="text" name="comment[body]" value="full bodied">

# Using +fields+ with +form_with+:
<%= form_with model: @post do |form| %>
  <%= form.text_field :title %>

  <%= form.fields :comment do |fields| %>
    <%= fields.text_field :body %>
  <% end %>
<% end %>

बहुत से FormBuilder उदाहरण के साथ स्कोप या मॉडल के साथ जुड़ा हुआ है, इसलिए किसी भी उत्पन्न क्षेत्र के नाम या तो पास किए गए स्कोप के साथ उपसर्ग किए गए हैं या स्कोप :model अनुमान लगाया गया है।

अन्य रूप सहायकों के साथ मिश्रण

जबकि form_with एक FormBuilder ऑब्जेक्ट का उपयोग करता है, जो कि FormBuilder से स्टैंड-अलोन FormHelper विधियों और विधियों का मिश्रण और मिलान करना संभव है:

<%= fields model: @comment do |fields| %>
  <%= fields.text_field :body %>

  <%= text_area :commenter, :biography %>
  <%= check_box_tag "comment[all_caps]", "1", @comment.commenter.hulk_mode? %>
<% end %>

समान FormOptionsHelper और DateHelper में एक बेस के रूप में ऑब्जेक्ट के साथ काम करने के लिए डिज़ाइन किए गए तरीकों के लिए जाता है, जैसे ActionView::Helpers::FormOptionsHelper#collection_select और ActionView::Helpers::DateHelper#datetime_select

field_for (record_name, record_object = nil, विकल्प = {}, और ब्लॉक) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1004
def fields_for(record_name, record_object = nil, options = {}, &block)
  builder = instantiate_builder(record_name, record_object, options)
  capture(builder, &block)
end

#form_for जैसी विशिष्ट मॉडल ऑब्जेक्ट के आसपास एक स्कोप बनाता है, लेकिन स्वयं प्रपत्र टैग नहीं बनाता है। यह अतिरिक्त मॉडल ऑब्जेक्ट्स को उसी रूप में निर्दिष्ट करने के लिए #fields_for उपयुक्त बनाता है।

यद्यपि fields_for का उपयोग और उद्देश्य fields_for के समान है, लेकिन इसका विधि हस्ताक्षर थोड़ा अलग है। form_for तरह, यह एक ब्लॉक मॉडल को एक विशेष मॉडल ऑब्जेक्ट से संबंधित एक ब्लॉक तक FormBuilder , और ब्लॉक के भीतर मॉडल ऑब्जेक्ट से जुड़े क्षेत्रों को उत्पन्न करने के लिए बिल्डर को तरीकों को कॉल करने की अनुमति देता है। फ़ील्ड एक मॉडल ऑब्जेक्ट को दो तरीकों से दर्शा सकते हैं - उनका नाम कैसे रखा जाता है (इसलिए नियंत्रक में params हैश के भीतर प्रस्तुत किए गए मान कैसे दिखाई देते हैं) और फ़ील्ड्स के रूप में पहली बार प्रदर्शित होने पर क्या डिफ़ॉल्ट मान दिखाए जाते हैं। इन दोनों विशेषताओं को स्वतंत्र रूप से निर्दिष्ट करने के लिए, एक वस्तु का नाम (दोनों एक प्रतीक या स्ट्रिंग द्वारा दर्शाया गया है) और ऑब्जेक्ट स्वयं अलग से विधि में पारित किया जा सकता है -

<%= form_for @person do |person_form| %>
  First name: <%= person_form.text_field :first_name %>
  Last name : <%= person_form.text_field :last_name %>

  <%= fields_for :permission, @person.permission do |permission_fields| %>
    Admin?  : <%= permission_fields.check_box :admin %>
  <% end %>

  <%= person_form.submit %>
<% end %>

इस स्थिति में, चेकबॉक्स फ़ील्ड को एचटीएमएल input टैग द्वारा प्रतिनिधित्व किया जाएगा जिसका name विशेषता permission[admin] , और जमा किया गया मान नियंत्रक params[:permission][:admin] रूप में दिखाई देगा। यदि @person.permission एक मौजूदा रिकॉर्ड है जो एक विशेषता admin , तो चेकबॉक्स की प्रारंभिक स्थिति जब पहली बार प्रदर्शित होती है, तो वह @person.permission.admin के मूल्य को दर्शाएगा।

अक्सर यह केवल fields_for ऑब्जेक्ट के लिए मॉडल ऑब्जेक्ट का नाम पास करके सरल किया जा सकता है -

<%= fields_for :permission do |permission_fields| %>
  Admin?: <%= permission_fields.check_box :admin %>
<% end %>

... जिस स्थिति में, यदि :permission भी एक उदाहरण चर @permission के नाम पर @permission , तो इनपुट फ़ील्ड की प्रारंभिक स्थिति उस चर के गुण @permission.admin के मान को दर्शाती है।

वैकल्पिक रूप से, आप केवल मॉडल ऑब्जेक्ट को ही पास कर सकते हैं (यदि पहला तर्क एक स्ट्रिंग या प्रतीक नहीं है तो fields_for को पता चलेगा कि नाम छोड़ दिया गया है) -

<%= fields_for @person.permission do |permission_fields| %>
  Admin?: <%= permission_fields.check_box :admin %>
<% end %>

और fields_for मॉडल ऑब्जेक्ट के वर्ग से फ़ील्ड का आवश्यक नाम प्राप्त करेगा, जैसे कि @person.permission , वर्ग Permission , फिर भी फ़ील्ड को permission[admin]

नोट: यह FormOptionsHelper और DateHelper में उन विधियों के लिए भी काम करता है जिन्हें किसी ऑब्जेक्ट के साथ बेस के रूप में कार्य करने के लिए डिज़ाइन किया गया है, जैसे ActionView::Helpers::FormOptionsHelper#collection_select और ActionView::Helpers::DateHelper#datetime_select

नेस्टेड एट्रिब्यूट्स उदाहरण हैं

जब वर्तमान क्षेत्र से संबंधित ऑब्जेक्ट में एक निश्चित विशेषता के लिए नेस्टेड विशेषता लेखक होता है, तो #fields_for उस विशेषता के लिए एक नया क्षेत्र उत्पन्न करेगा। यह आपको ऐसे रूपों को बनाने की अनुमति देता है जो एक मूल वस्तु और उसके संघों की विशेषताओं को एक बार में सेट या परिवर्तित करते हैं।

नेस्टेड विशेषता लेखक एक संघ के नाम पर सामान्य सेटर विधियां हैं। इन लेखकों को परिभाषित करने का सबसे आम तरीका या तो एक मॉडल परिभाषा में accepts_nested_attributes_for साथ है या उचित नाम के साथ एक विधि को परिभाषित करके। उदाहरण के लिए: एसोसिएशन के लिए विशेषता लेखक :address को address_attributes= कहा जाता है।

चाहे वन-टू-वन या वन-टू-कई स्टाइल फॉर्म बिल्डर का उत्पादन किया जाएगा, यह इस बात पर निर्भर करता है कि सामान्य रीडर विधि किसी एकल ऑब्जेक्ट या ऑब्जेक्ट की एक सरणी देता है या नहीं।

एक से एक

एक व्यक्ति वर्ग पर विचार करें जो address रीडर विधि से एक एकल पता लौटाता है और address_attributes= लेखक विधि का जवाब देता है:

class Person
  def address
    @address
  end

  def address_attributes=(attributes)
    # Process the attributes hash
  end
end

इस मॉडल को अब नेस्टेड #fields_for साथ प्रयोग किया जा सकता है, जैसे:

<%= form_for @person do |person_form| %>
  ...
  <%= person_form.fields_for :address do |address_fields| %>
    Street  : <%= address_fields.text_field :street %>
    Zip code: <%= address_fields.text_field :zip_code %>
  <% end %>
  ...
<% end %>

जब पता पहले से ही एक व्यक्ति पर एक संघ है तो आप अपने लिए लेखक विधि को परिभाषित करने के लिए accepts_nested_attributes_for का उपयोग कर सकते हैं:

class Person < ActiveRecord::Base
  has_one :address
  accepts_nested_attributes_for :address
end

यदि आप प्रपत्र के माध्यम से संबद्ध मॉडल को नष्ट करना चाहते हैं, तो आपको पहले इसका उपयोग करके इसे सक्षम करना होगा :allow_destroy विकल्प के लिए accepts_nested_attributes_for :

class Person < ActiveRecord::Base
  has_one :address
  accepts_nested_attributes_for :address, allow_destroy: true
end

अब, जब आप _destroy पैरामीटर के साथ एक फॉर्म एलिमेंट का उपयोग करते हैं, तो ऐसे मान के साथ जो true मूल्यांकन करता true , आप संबंधित मॉडल (जैसे। 1, '1', ट्रू या 'true') को नष्ट कर देंगे:

<%= form_for @person do |person_form| %>
  ...
  <%= person_form.fields_for :address do |address_fields| %>
    ...
    Delete: <%= address_fields.check_box :_destroy %>
  <% end %>
  ...
<% end %>

अनेको के लिये एक

एक व्यक्ति वर्ग पर विचार करें, जो projects रीडर से प्रोजेक्ट इंस्टेंस की एक सरणी लौटाता है और प्रॉजेक्ट्स के प्रति प्रतिक्रिया करता है_attributes projects_attributes= लेखक विधि:

class Person
  def projects
    [@project1, @project2]
  end

  def projects_attributes=(attributes)
    # Process the attributes hash
  end
end

ध्यान दें कि #fields_for projects_attributes= लेखक विधि वास्तव में सही पहचान करने के लिए #fields_for लिए आवश्यक है :projects संग्रह के रूप में :projects , और फॉर्म मार्कअप में सेट किए जाने वाले सही सूचकांक।

जब परियोजनाएं पहले से ही व्यक्ति पर एक संघ है, तो आप अपने लिए लेखक विधि को परिभाषित करने के लिए accepts_nested_attributes_for का उपयोग कर सकते हैं:

class Person < ActiveRecord::Base
  has_many :projects
  accepts_nested_attributes_for :projects
end

यह मॉडल अब नेस्टेड फ़ील्ड्स के लिए उपयोग किया जा सकता है। नेस्टेड #fields_for कॉल के लिए दिया गया ब्लॉक संग्रह में प्रत्येक उदाहरण के लिए दोहराया जाएगा:

<%= form_for @person do |person_form| %>
  ...
  <%= person_form.fields_for :projects do |project_fields| %>
    <% if project_fields.object.active? %>
      Name: <%= project_fields.text_field :name %>
    <% end %>
  <% end %>
  ...
<% end %>

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

<%= form_for @person do |person_form| %>
  ...
  <% @person.projects.each do |project| %>
    <% if project.active? %>
      <%= person_form.fields_for :projects, project do |project_fields| %>
        Name: <%= project_fields.text_field :name %>
      <% end %>
    <% end %>
  <% end %>
  ...
<% end %>

या इस्तेमाल किया जाने वाला एक संग्रह:

<%= form_for @person do |person_form| %>
  ...
  <%= person_form.fields_for :projects, @active_projects do |project_fields| %>
    Name: <%= project_fields.text_field :name %>
  <% end %>
  ...
<% end %>

यदि आप किसी भी संबंधित मॉडल को फ़ॉर्म के माध्यम से नष्ट करना चाहते हैं, तो आपको पहले इसका उपयोग करके इसे सक्षम करना होगा :allow_destroy विकल्प के लिए accepts_nested_attributes_for :

class Person < ActiveRecord::Base
  has_many :projects
  accepts_nested_attributes_for :projects, allow_destroy: true
end

यह आपको निर्दिष्ट करेगा कि कौन से मॉडल विशेषताओं में नष्ट करने के लिए हैश में _destroy पैरामीटर के लिए एक फॉर्म एलिमेंट जोड़कर ऐसे मान के साथ होता है जो true मूल्यांकन करता true (जैसे। 1, '1', सत्य या 'सही')।

<%= form_for @person do |person_form| %>
  ...
  <%= person_form.fields_for :projects do |project_fields| %>
    Delete: <%= project_fields.check_box :_destroy %>
  <% end %>
  ...
<% end %>

जब एक संग्रह का उपयोग किया जाता है तो आप सरणी में प्रत्येक वस्तु के सूचकांक को जानना चाह सकते हैं। इस प्रयोजन के लिए, index विधि FormBuilder ऑब्जेक्ट में उपलब्ध है।

<%= form_for @person do |person_form| %>
  ...
  <%= person_form.fields_for :projects do |project_fields| %>
    Project #<%= project_fields.index %>
    ...
  <% end %>
  ...
<% end %>

ध्यान दें कि #fields_for स्वचालित रूप से रिकॉर्ड की आईडी स्टोर करने के लिए एक छिपा हुआ क्षेत्र उत्पन्न करेगा। ऐसी परिस्थितियां हैं जहां इस छिपे हुए क्षेत्र की आवश्यकता नहीं है और आप इसमें शामिल कर सकते #fields_for include_id: false #fields_for को स्वचालित रूप से रेंडर करने से रोकने के लिए include_id: false

file_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1206
def file_field(object_name, method, options = {})
  Tags::FileField.new(object_name, method, self, convert_direct_upload_option_to_url(options.dup)).render
end

टेम्प्लेट को निर्दिष्ट ऑब्जेक्ट पर एक निर्दिष्ट विशेषता ( method द्वारा पहचाना गया) तक पहुँचने के लिए एक फ़ाइल अपलोड इनपुट टैग देता है ( object द्वारा पहचाना गया)। इनपुट टैग पर अतिरिक्त विकल्पों को options साथ हैश के रूप में पारित किया जा सकता है। इन विकल्पों को HTML में HTML तत्व विशेषता के रूप में दिखाया गया है जैसा कि दिखाया गया है।

एक form_for block के अंदर इस विधि का उपयोग करने से enclosing फॉर्म का एन्कोडिंग multipart/form-data सेट हो जाएगा।

विकल्प

  • टैग के लिए मानक HTML विशेषताएँ बनाता है।

  • :disabled - यदि इसे सही पर सेट किया गया है, तो उपयोगकर्ता इस इनपुट का उपयोग नहीं कर सकेगा।

  • :multiple - यदि सही पर सेट है, तो * अधिकांश अपडेट किए गए ब्राउज़रों में * उपयोगकर्ता को कई फ़ाइलों का चयन करने की अनुमति होगी।

  • :accept - यदि एक या कई माइम-प्रकारों पर सेट किया जाता है, तो उपयोगकर्ता को एक फ़ाइल चुनते समय एक फिल्टर का सुझाव दिया जाएगा। आपको अभी भी मॉडल सत्यापन सेट करने की आवश्यकता है।

उदाहरण

file_field(:user, :avatar)
# => <input type="file" id="user_avatar" name="user[avatar]" />

file_field(:post, :image, multiple: true)
# => <input type="file" id="post_image" name="post[image][]" multiple="multiple" />

file_field(:post, :attached, accept: 'text/html')
# => <input accept="text/html" type="file" id="post_attached" name="post[attached]" />

file_field(:post, :image, accept: 'image/png,image/gif,image/jpeg')
# => <input type="file" id="post_image" name="post[image]" accept="image/png,image/gif,image/jpeg" />

file_field(:attachment, :file, class: 'file_input')
# => <input type="file" id="attachment_file" name="attachment[file]" class="file_input" />
form_for (रिकॉर्ड, विकल्प = {}, और ब्लॉक) शो स्रोत
# File actionview/lib/action_view/helpers/form_helper.rb, line 430
def form_for(record, options = {}, &block)
  raise ArgumentError, "Missing block" unless block_given?
  html_options = options[:html] ||= {}

  case record
  when String, Symbol
    object_name = record
    object      = nil
  else
    object      = record.is_a?(Array) ? record.last : record
    raise ArgumentError, "First argument in form cannot contain nil or be empty" unless object
    object_name = options[:as] || model_name_from_record_or_class(object).param_key
    apply_form_for_options!(record, object, options)
  end

  html_options[:data]   = options.delete(:data)   if options.has_key?(:data)
  html_options[:remote] = options.delete(:remote) if options.has_key?(:remote)
  html_options[:method] = options.delete(:method) if options.has_key?(:method)
  html_options[:enforce_utf8] = options.delete(:enforce_utf8) if options.has_key?(:enforce_utf8)
  html_options[:authenticity_token] = options.delete(:authenticity_token)

  builder = instantiate_builder(object_name, object, options)
  output  = capture(builder, &block)
  html_options[:multipart] ||= builder.multipart?

  html_options = html_options_for_form(options[:url] || {}, html_options)
  form_tag_with_body(html_options, output)
end

एक ऐसा रूप बनाता है जो उपयोगकर्ता को किसी विशिष्ट मॉडल ऑब्जेक्ट की विशेषताओं को बनाने या अपडेट करने की अनुमति देता है।

विधि का उपयोग कई अलग-अलग तरीकों से किया जा सकता है, इस पर निर्भर करता है कि आप मॉडल से स्वचालित रूप से अनुमान लगाने के लिए रेल पर भरोसा करना चाहते हैं कि फॉर्म का निर्माण कैसे किया जाना चाहिए। जेनेरिक मॉडल ऑब्जेक्ट के लिए, एक फॉर्म form_for स्ट्रिंग या प्रतीक को पास करके बनाया जा सकता है जो उस वस्तु का प्रतिनिधित्व करता है जिसे हम संबंधित हैं:

<%= form_for :person do |f| %>
  First name: <%= f.text_field :first_name %><br />
  Last name : <%= f.text_field :last_name %><br />
  Biography : <%= f.text_area :biography %><br />
  Admin?    : <%= f.check_box :admin %><br />
  <%= f.submit %>
<% end %>

ब्लॉक को दिए गए चर f एक FormBuilder ऑब्जेक्ट है जो उस मॉडल प्रतिनिधित्व के बारे में ज्ञान को शामिल करता है जो :person द्वारा प्रस्तुत किया जाता है :person form_for लिए पास किया गया :person FormBuilder पर परिभाषित तरीके इस मॉडल से जुड़े क्षेत्रों को उत्पन्न करने के लिए उपयोग किए FormBuilder हैं। इस प्रकार, उदाहरण के लिए,

<%= f.text_field :first_name %>

का विस्तार किया जाएगा

<%= text_field :person, :first_name %>

जिसके परिणामस्वरूप HTML <input> टैग होता है जिसका name विशेषता person[first_name] । इसका मतलब यह है कि जब फॉर्म सबमिट किया जाता है, तो उपयोगकर्ता द्वारा दर्ज किया गया मान नियंत्रक params[:person][:first_name] रूप में नियंत्रक में उपलब्ध होगा।

FormBuilder का उपयोग करके इस तरह से उत्पन्न क्षेत्रों के लिए, यदि :person भी एक उदाहरण चर @person के नाम से होता है, तो फ़ील्ड का डिफ़ॉल्ट मान तब दिखाया जाता है जब फॉर्म शुरू में प्रदर्शित होता है (जैसे उस स्थिति में जहां आप किसी मौजूदा को संपादित कर रहे हैं रिकॉर्ड) @person की संबंधित विशेषता का मूल्य होगा।

form_for का सबसे सही तर्क विकल्पों का एक वैकल्पिक हैश है -

  • :url - URL जिस रूप में सबमिट किया जाना है। इसे उसी तरह से दर्शाया जा सकता है जैसे कि url_for या url_for को url_for गए मान। इसलिए उदाहरण के लिए आप सीधे नामित मार्ग का उपयोग कर सकते हैं। जब मॉडल को एक स्ट्रिंग या प्रतीक द्वारा दर्शाया जाता है, जैसा कि ऊपर दिए गए उदाहरण में, यदि :url विकल्प निर्दिष्ट नहीं है, तो डिफ़ॉल्ट रूप से प्रपत्र वर्तमान URL पर वापस भेज दिया जाएगा (हम एक वैकल्पिक संसाधन-उन्मुख उपयोग के नीचे वर्णन करेंगे form_for जिसमें URL को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है)।

  • :namespace - आपके नाम के लिए एक नामस्थान, जो फार्म तत्वों पर आईडी विशेषताओं की विशिष्टता सुनिश्चित करता है। नामस्थान विशेषता उत्पन्न HTML आईडी पर अंडरस्कोर के साथ उपसर्ग किया जाएगा।

  • :method - फॉर्म जमा करते समय उपयोग करने की विधि, आमतौर पर या तो "मिलता है" या "पोस्ट"। यदि "पैच", "पुट", "डिलीट", या एक और क्रिया का उपयोग किया जाता है, तो पोस्ट के साथ क्रिया को अनुकरण करने के लिए _method नाम के साथ एक छिपा हुआ इनपुट जोड़ा जाता है।

  • :authenticity_token - प्रपत्र में उपयोग करने के लिए प्रामाणिकता टोकन। केवल तभी उपयोग करें जब आपको कस्टम प्रामाणिकता टोकन स्ट्रिंग पास करने की आवश्यकता हो, या ऑथेंटिसिटी_टोकन फ़ील्ड को बिल्कुल भी न जोड़ें ( false )। दूरस्थ रूप config.action_view.embed_authenticity_token_in_remote_forms = false सेट करके एम्बेडेड प्रामाणिकता टोकन को छोड़ सकते हैं। जब आप फ़ॉर्म को कैशिंग-कैशिंग करते हैं तो यह सहायक होता है। रिमोट टैग meta टैग से प्रामाणिकता टोकन प्राप्त करते हैं, इसलिए एम्बेडिंग अनावश्यक है जब तक कि आप जावास्क्रिप्ट के बिना ब्राउज़रों का समर्थन नहीं करते हैं।

  • :remote - यदि सही पर सेट है, तो विनीत जावास्क्रिप्ट ड्राइवरों को सबमिट व्यवहार को नियंत्रित करने की अनुमति देगा। डिफ़ॉल्ट रूप से यह व्यवहार एक अजाक्स सबमिट है।

  • :enforce_utf8 - यदि गलत पर सेट किया गया है, तो utf8 नाम का एक छिपा हुआ इनपुट आउटपुट नहीं है।

  • :html - फॉर्म टैग के लिए वैकल्पिक HTML विशेषताएँ।

यह भी ध्यान दें कि form_for एक विशेष क्षेत्र नहीं बनाता है। FormHelper से स्टैंड-अलोन FormHelper विधियों और विधियों दोनों का उपयोग करना अभी भी संभव है। उदाहरण के लिए:

<%= form_for :person do |f| %>
  First name: <%= f.text_field :first_name %>
  Last name : <%= f.text_field :last_name %>
  Biography : <%= text_area :person, :biography %>
  Admin?    : <%= check_box_tag "person[admin]", "1", @person.company.admin? %>
  <%= f.submit %>
<% end %>

यह FormOptionsHelper और DateHelper में उन विधियों के लिए भी काम करता है, जिन्हें किसी ऑब्जेक्ट के साथ बेस के रूप में कार्य करने के लिए डिज़ाइन किया गया है, जैसे ActionView::Helpers::FormOptionsHelper#collection_select और ActionView::Helpers::DateHelper#datetime_select

#form_for एक मॉडल ऑब्जेक्ट के साथ

ऊपर दिए गए उदाहरणों में, बनाने या संपादित किए जाने वाले ऑब्जेक्ट को form_for को form_for गए प्रतीक द्वारा दर्शाया गया था, और हमने नोट किया कि एक स्ट्रिंग का भी समकक्ष उपयोग किया जा सकता है। हालाँकि, यह संभव है कि किसी मॉडल ऑब्जेक्ट को form_for ही पास किया form_for । उदाहरण के लिए, यदि @post एक मौजूदा रिकॉर्ड है जिसे आप संपादित करना चाहते हैं, तो आप फॉर्म का उपयोग करके बना सकते हैं

<%= form_for @post do |f| %>
  ...
<% end %>

यह लगभग उसी तरह से व्यवहार करता है जैसा कि पहले उल्लिखित है, कुछ अपवादों के साथ। सबसे पहले, उपसर्गों को फार्म के भीतर इनपुट तत्वों का नाम दिया जाता है (इसलिए कुंजी जो उन्हें params हैश में दर्शाती है) वास्तव में ऑब्जेक्ट की कक्षा से ली गई है, उदाहरण के लिए params[:post] यदि ऑब्जेक्ट की क्लास Post । हालाँकि, इसका उपयोग करके ओवरराइट किया जा सकता है :as विकल्प के :as , जैसे -

<%= form_for(@person, as: :client) do |f| %>
  ...
<% end %>

नतीजा यह होगा कि params[:client]

दूसरी बात, जब फार्म को शुरू में प्रदर्शित किया जाता है तो फ़ील्ड मानों को ऑब्जेक्ट के उन गुणों से लिया जाता है, जिन्हें form_for में दिए गए ऑब्जेक्ट से अलग किया जाता है, भले ही ऑब्जेक्ट एक इंस्टेंस वेरिएबल हो। इसलिए, उदाहरण के लिए, यदि हमारे पास एक स्थानीय चर post था जो मौजूदा रिकॉर्ड का प्रतिनिधित्व करता है,

<%= form_for post do |f| %>
  ...
<% end %>

खेतों के साथ एक फार्म का उत्पादन करेगा जिसकी प्रारंभिक स्थिति post की विशेषताओं के वर्तमान मूल्यों को दर्शाती है।

संसाधन-उन्मुख शैली

केवल दिखाए गए उदाहरणों में, हालांकि स्पष्ट रूप से संकेत नहीं किया गया है, फिर भी हमें यह निर्दिष्ट करने के लिए :url प्रपत्र भेजने के लिए :url विकल्प का उपयोग करने की आवश्यकता है। हालाँकि, आगे सरलीकरण संभव है यदि form_for लिए दिया गया रिकॉर्ड एक संसाधन है , अर्थात यह form_for मार्गों के एक सेट से मेल खाता है, जैसे कि config/routes.rb में resources विधि का उपयोग करके परिभाषित किया गया है। इस मामले में रेल केवल रिकॉर्ड से ही उपयुक्त URL का अनुमान लगा लेगी। उदाहरण के लिए,

<%= form_for @post do |f| %>
  ...
<% end %>

फिर कुछ के बराबर है:

<%= form_for @post, as: :post, url: post_path(@post), method: :patch, html: { class: "edit_post", id: "edit_post_45" } do |f| %>
  ...
<% end %>

और एक नए रिकॉर्ड के लिए

<%= form_for(Post.new) do |f| %>
  ...
<% end %>

कुछ इस तरह के बराबर है:

<%= form_for @post, as: :post, url: posts_path, html: { class: "new_post", id: "new_post" } do |f| %>
  ...
<% end %>

हालाँकि आप अभी भी व्यक्तिगत सम्मेलनों को अधिलेखित कर सकते हैं, जैसे:

<%= form_for(@post, url: super_posts_path) do |f| %>
  ...
<% end %>

आप उत्तर प्रारूप भी सेट कर सकते हैं, जैसे:

<%= form_for(@post, format: :json) do |f| %>
  ...
<% end %>

admin_post_url मार्गों के लिए, जैसे admin_post_url :

<%= form_for([:admin, @post]) do |f| %>
 ...
<% end %>

यदि आपके संसाधन में संबद्धताएं हैं, उदाहरण के लिए, आप दिए गए दस्तावेज़ में टिप्पणी जोड़ना चाहते हैं कि मार्ग सही तरीके से सेट किए गए हैं:

<%= form_for([@document, @comment]) do |f| %>
 ...
<% end %>

जहाँ पर @document = Document.find(params[:id]) और @comment = Comment.new

विधि निर्धारित करना

आप फॉर्म को HTTP क्रिया की पूर्ण सरणी का उपयोग करके सेटिंग के लिए बाध्य कर सकते हैं

method: (:get|:post|:patch|:put|:delete)

विकल्पों में हैश। यदि क्रिया GET या POST नहीं है, जो HTML रूपों द्वारा मूल रूप से समर्थित हैं, तो प्रपत्र POST पर सेट हो जाएगा और एक छिपा हुआ इनपुट जिसे _method कहा जाता है, सर्वर की व्याख्या करने के लिए इच्छित क्रिया को ले जाएगा।

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

निर्दिष्ट करना:

remote: true

विकल्प में हैश एक ऐसा रूप बनाता है जो विनीत जावास्क्रिप्ट ड्राइवरों को अपने व्यवहार को संशोधित करने की अनुमति देगा। अपेक्षित डिफ़ॉल्ट व्यवहार नियमित POST व्यवस्था के बजाय पृष्ठभूमि में एक XMLHttpRequest है, लेकिन अंततः व्यवहार जावास्क्रिप्ट चालक कार्यान्वयन का विकल्प है। भले ही यह फॉर्म तत्वों को क्रमबद्ध करने के लिए जावास्क्रिप्ट का उपयोग कर रहा है, लेकिन फॉर्म सबमिशन नियमित रूप से जमा करने की तरह ही काम करेगा, जैसा कि प्राप्त पक्ष ( params में उपलब्ध सभी तत्व) द्वारा देखा जाता है।

उदाहरण:

<%= form_for(@post, remote: true) do |f| %>
  ...
<% end %>

इस के लिए उत्पन्न HTML होगा:

<form action='http://www.example.com' method='post' data-remote='true'>
  <input name='_method' type='hidden' value='patch' />
  ...
</form>

HTML विकल्प सेट करना

आप डेटा विशेषताओं को सीधे डेटा हैश में पास करके सेट कर सकते हैं, लेकिन अन्य सभी HTML विकल्पों को HTML कुंजी में लपेटा जाना चाहिए। उदाहरण:

<%= form_for(@post, data: { behavior: "autosave" }, html: { name: "go" }) do |f| %>
  ...
<% end %>

इस के लिए उत्पन्न HTML होगा:

<form action='http://www.example.com' method='post' data-behavior='autosave' name='go'>
  <input name='_method' type='hidden' value='patch' />
  ...
</form>

छिपी हुई मॉडल आईडी को हटाना

#form_for विधि में स्वचालित रूप से मॉडल आईडी को एक छिपे हुए फ़ील्ड के रूप में शामिल किया गया है। इसका उपयोग प्रपत्र डेटा और उसके संबंधित मॉडल के बीच संबंध को बनाए रखने के लिए किया जाता है। कुछ ORM सिस्टम नेस्टेड मॉडल पर आईडी का उपयोग नहीं करते हैं इसलिए इस मामले में आप छिपी हुई आईडी को निष्क्रिय करने में सक्षम होना चाहते हैं।

निम्नलिखित उदाहरण में पोस्ट मॉडल में NoSQL डेटाबेस में कई टिप्पणियाँ संग्रहीत हैं, इस प्रकार टिप्पणियों के लिए कोई प्राथमिक कुंजी नहीं है।

उदाहरण:

<%= form_for(@post) do |f| %>
  <%= f.fields_for(:comments, include_id: false) do |cf| %>
    ...
  <% end %>
<% end %>

अनुकूलित प्रपत्र बिल्डरों

आप स्वनिर्धारित FormBuilder वर्ग का उपयोग करके प्रपत्र भी बना सकते हैं। Subclass FormBuilder और ओवरराइड करें या कुछ और सहायकों को परिभाषित करें, फिर अपने कस्टम बिल्डर का उपयोग करें। उदाहरण के लिए, मान लें कि आपने इनपुट बनाने के लिए लेबलों को स्वचालित रूप से जोड़ने के लिए एक सहायक बनाया है।

<%= form_for @person, url: { action: "create" }, builder: LabellingFormBuilder do |f| %>
  <%= f.text_field :first_name %>
  <%= f.text_field :last_name %>
  <%= f.text_area :biography %>
  <%= f.check_box :admin %>
  <%= f.submit %>
<% end %>

इस मामले में, यदि आप इसका उपयोग करते हैं:

<%= render f %>

प्रदान किया गया टेम्प्लेट people/_labelling_form और फार्म चर का संदर्भ देने वाले स्थानीय चर को labelling_form कहा जाता है।

जब तक यह स्पष्ट रूप से सेट नहीं किया जाता है तब तक कस्टम FormBuilder क्लास स्वचालित रूप से एक नेस्टेड #fields_for कॉल के विकल्पों के साथ विलय कर दिया जाता है।

कई मामलों में आप ऊपर वाले को दूसरे सहायक में लपेटना चाहेंगे, इसलिए आप निम्नलिखित कुछ कर सकते हैं:

def labelled_form_for(record_or_name_or_array, *args, &block)
  options = args.extract_options!
  form_for(record_or_name_or_array, *(args << options.merge(builder: LabellingFormBuilder)), &block)
end

यदि आपको किसी मॉडल उदाहरण के लिए प्रपत्र संलग्न करने की आवश्यकता नहीं है, तो ActionView::Helpers::FormTagHelper#form_tag

बाहरी संसाधनों के लिए फार्म

जब आप बाहरी संसाधनों के लिए प्रपत्र बनाते हैं, तो कभी-कभी आपको एक प्रमाणिक टोकन सेट करने की आवश्यकता होती है या इसके बिना केवल एक प्रपत्र प्रस्तुत करना होता है, उदाहरण के लिए जब आप भुगतान गेटवे नंबर पर डेटा सबमिट करते हैं और फ़ील्ड के प्रकार सीमित हो सकते हैं।

एक प्रामाणिकता टोकन सेट करने के लिए आपको एक :authenticity_token पैरामीटर पास करना होगा

<%= form_for @invoice, url: external_url, authenticity_token: 'external_token' do |f| %>
  ...
<% end %>

यदि आप एक प्रामाणिक टोकन फ़ील्ड नहीं चाहते हैं, तो सभी false से प्रस्तुत किए जाएंगे:

<%= form_for @invoice, url: external_url, authenticity_token: false do |f| %>
  ...
<% end %>
form_with (मॉडल: nil, स्कोप: nil, url: nil, format: nil, ** ऑप्शंस) दिखाएँ स्रोत
# File actionview/lib/action_view/helpers/form_helper.rb, line 739
def form_with(model: nil, scope: nil, url: nil, format: nil, **options)
  options[:allow_method_names_outside_object] = true
  options[:skip_default_ids] = !form_with_generates_ids

  if model
    url ||= polymorphic_path(model, format: format)

    model   = model.last if model.is_a?(Array)
    scope ||= model_name_from_record_or_class(model).param_key
  end

  if block_given?
    builder = instantiate_builder(scope, model, options)
    output  = capture(builder, &Proc.new)
    options[:multipart] ||= builder.multipart?

    html_options = html_options_for_form_with(url, model, options)
    form_tag_with_body(html_options, output)
  else
    html_options = html_options_for_form_with(url, model, options)
    form_tag_html(html_options)
  end
end

URL, स्कोप या मॉडल के मिश्रण के आधार पर एक फॉर्म टैग बनाता है।

# Using just a URL:
<%= form_with url: posts_path do |form| %>
  <%= form.text_field :title %>
<% end %>
# =>
<form action="/posts" method="post" data-remote="true">
  <input type="text" name="title">
</form>

# Adding a scope prefixes the input field names:
<%= form_with scope: :post, url: posts_path do |form| %>
  <%= form.text_field :title %>
<% end %>
# =>
<form action="/posts" method="post" data-remote="true">
  <input type="text" name="post[title]">
</form>

# Using a model infers both the URL and scope:
<%= form_with model: Post.new do |form| %>
  <%= form.text_field :title %>
<% end %>
# =>
<form action="/posts" method="post" data-remote="true">
  <input type="text" name="post[title]">
</form>

# An existing model makes an update form and fills out field values:
<%= form_with model: Post.first do |form| %>
  <%= form.text_field :title %>
<% end %>
# =>
<form action="/posts/1" method="post" data-remote="true">
  <input type="hidden" name="_method" value="patch">
  <input type="text" name="post[title]" value="<the title of the post>">
</form>

# Though the fields don't have to correspond to model attributes:
<%= form_with model: Cat.new do |form| %>
  <%= form.text_field :cats_dont_have_gills %>
  <%= form.text_field :but_in_forms_they_can %>
<% end %>
# =>
<form action="/cats" method="post" data-remote="true">
  <input type="text" name="cat[cats_dont_have_gills]">
  <input type="text" name="cat[but_in_forms_they_can]">
</form>

प्रपत्रों में पैरामीटर उनके नाम घोंसले के शिकार के अनुसार नियंत्रकों में सुलभ हैं। इसलिए title और post[title] नाम के इनपुट क्रमशः params[:title] और params[:post][:title] params[:title] रूप में सुलभ हैं।

डिफ़ॉल्ट form_with data-remote विशेषता को XML में एक XMLHTTPRequest के माध्यम से फ़ॉर्म सबमिट करने के लिए देता है, अगर एक विनीत जावास्क्रिप्ट ड्राइवर, जैसे रेल- ujs, का उपयोग किया जाता है। अधिक के लिए :local विकल्प देखें।

तुलना करने में आसानी के लिए ऊपर दिए गए उदाहरण सबमिट बटन को छोड़ दें, साथ ही ऑटो जेनरेट किए गए छिपे हुए फ़ील्ड जो UTF-8 समर्थन को सक्षम करते हैं और क्रॉस साइट अनुरोध जालसाजी सुरक्षा के लिए आवश्यक प्रामाणिकता टोकन जोड़ते हैं।

संसाधन-उन्मुख शैली

अभी दिखाए गए कई उदाहरणों में :model form_with से पास किया गया :model एक संसाधन है । यह रेस्टफुल मार्गों के एक सेट से मेल खाता है, सबसे अधिक संभावना है कि यह config/routes.rb माध्यम से config/routes.rb

इसलिए इस तरह के एक मॉडल रिकॉर्ड को पारित करते समय, रेल यूआरएल और विधि को संक्रमित करता है।

<%= form_with model: @post do |form| %>
  ...
<% end %>

फिर कुछ के बराबर है:

<%= form_with scope: :post, url: post_path(@post), method: :patch do |form| %>
  ...
<% end %>

और एक नए रिकॉर्ड के लिए

<%= form_with model: Post.new do |form| %>
  ...
<% end %>

कुछ इस तरह के बराबर है:

<%= form_with scope: :post, url: posts_path do |form| %>
  ...
<% end %>

form_with विकल्प

  • :url - URL जिस रूप में सबमिट होता है। url_for या url_for को url_for गए मानों में अकिन। उदाहरण के लिए, आप सीधे नामित मार्ग का उपयोग कर सकते हैं। जब a :scope बिना पास हो जाती है :url फॉर्म को केवल वर्तमान URL में सबमिट करता है।

  • :method - फॉर्म जमा करते समय उपयोग करने की विधि, आमतौर पर या तो "मिलता है" या "पोस्ट"। यदि "पैच", "पुट", "डिलीट", या किसी अन्य क्रिया का उपयोग किया जाता है, तो पोस्ट पर क्रिया को अनुकरण करने के लिए _method नामक एक छिपा हुआ इनपुट जोड़ा जाता है।

  • :format - मार्ग का प्रारूप जिस रूप में प्रस्तुत होता है। दूसरे संसाधन प्रकार में सबमिट करते समय उपयोगी, जैसे :json । छोड़ दिया अगर :url a।

  • :scope - इनपुट फ़ील्ड नामों के साथ उपसर्ग करने की गुंजाइश और इस तरह कैसे प्रस्तुत किए गए मापदंडों को नियंत्रकों में वर्गीकृत किया जाता है।

  • :model - ए मॉडल ऑब्जेक्ट इन द अर्ल :url और :scope बाय, प्लस इनपुट फील्ड वैल्यूज भरें। इसलिए यदि एक title विशेषता "अहोई!" पर सेट है, तो एक title इनपुट फ़ील्ड का मान "अहोई!" होगा। यदि मॉडल एक नया रिकॉर्ड है तो एक क्रिएट फॉर्म जेनरेट होता है, यदि कोई मौजूदा रिकॉर्ड, हालांकि, एक अपडेट फॉर्म जेनरेट होता है। पास :scope या :url डिफ़ॉल्ट को ओवरराइड करने के लिए :url । एग टर्न params[:post] इन params[:article]

  • :authenticity_token - प्रपत्र में उपयोग करने के लिए प्रामाणिकता टोकन। एक कस्टम प्रामाणिकता टोकन के साथ ओवरराइड करें या प्रामाणिकता टोकन फ़ील्ड को पूरी तरह से छोड़ने के लिए false पास करें। भुगतान गेटवे जैसे बाहरी संसाधन को सबमिट करते समय उपयोगी है जो मान्य फ़ील्ड को सीमित कर सकता है। दूरस्थ रूप config.action_view.embed_authenticity_token_in_remote_forms = false सेट करके एम्बेडेड प्रामाणिकता टोकन को छोड़ सकते हैं। यह उपयोगी है जब टुकड़ा-कैशिंग प्रपत्र। रिमोट टैग meta टैग से प्रामाणिकता टोकन प्राप्त करते हैं, इसलिए एम्बेडिंग अनावश्यक है जब तक कि आप जावास्क्रिप्ट के बिना ब्राउज़रों का समर्थन नहीं करते हैं।

  • :local - डिफ़ॉल्ट रूप से सबमिशन रिमोट और विनीत एक्सएचआर हैं। local: true साथ दूरस्थ सबमिशन को अक्षम करें local: true

  • :skip_enforcing_utf8 - डिफ़ॉल्ट रूप से utf8 नाम का एक छिपा हुआ क्षेत्र UTF-8 :skip_enforcing_utf8 को लागू करने के लिए आउटपुट है। फ़ील्ड को छोड़ने के लिए सही पर सेट करें।

  • :builder - फॉर्म को बनाने के लिए उपयोग की जाने वाली वस्तु को ओवरराइड करें।

  • :id - वैकल्पिक HTML आईडी विशेषता।

  • :class - वैकल्पिक HTML वर्ग विशेषता।

  • :data - वैकल्पिक HTML डेटा विशेषताएँ।

  • :html - प्रपत्र टैग के लिए अन्य वैकल्पिक HTML विशेषताएँ।

उदाहरण

जब कोई ब्लॉक पास नहीं होता है, तो form_with केवल एक ओपनिंग फॉर्म टैग बनाता है।

<%= form_with(model: @post, url: super_posts_path) %>
<%= form_with(model: @post, scope: :article) %>
<%= form_with(model: @post, format: :json) %>
<%= form_with(model: @post, authenticity_token: false) %> # Disables the token.

admin_post_url मार्गों के लिए, जैसे admin_post_url :

<%= form_with(model: [ :admin, @post ]) do |form| %>
  ...
<% end %>

यदि आपके संसाधन में संबद्धताएं हैं, उदाहरण के लिए, आप दिए गए दस्तावेज़ में टिप्पणी जोड़ना चाहते हैं कि मार्ग सही तरीके से सेट किए गए हैं:

<%= form_with(model: [ @document, Comment.new ]) do |form| %>
  ...
<% end %>

जहाँ पर @document = Document.find(params[:id])

अन्य रूप सहायकों के साथ मिश्रण

जबकि form_with एक FormBuilder ऑब्जेक्ट का उपयोग करता है, जो कि FormBuilder से स्टैंड-अलोन FormHelper विधियों और विधियों का मिश्रण और मिलान करना संभव है:

<%= form_with scope: :person do |form| %>
  <%= form.text_field :first_name %>
  <%= form.text_field :last_name %>

  <%= text_area :person, :biography %>
  <%= check_box_tag "person[admin]", "1", @person.company.admin? %>

  <%= form.submit %>
<% end %>

समान FormOptionsHelper और DateHelper में एक बेस के रूप में ऑब्जेक्ट के साथ काम करने के लिए डिज़ाइन किए गए तरीकों के लिए जाता है, जैसे ActionView::Helpers::FormOptionsHelper#collection_select और ActionView::Helpers::DateHelper#datetime_select

विधि निर्धारित करना

आप फॉर्म को HTTP क्रिया की पूर्ण सरणी का उपयोग करके सेटिंग के लिए बाध्य कर सकते हैं

method: (:get|:post|:patch|:put|:delete)

विकल्पों में हैश। यदि क्रिया GET या POST नहीं है, जो HTML रूपों द्वारा मूल रूप से समर्थित हैं, तो प्रपत्र POST पर सेट हो जाएगा और एक छिपा हुआ इनपुट जिसे _method कहा जाता है, सर्वर की व्याख्या करने के लिए इच्छित क्रिया को ले जाएगा।

HTML विकल्प सेट करना

आप डेटा विशेषताओं को सीधे डेटा हैश में सेट कर सकते हैं, लेकिन आईडी और क्लास के अलावा एचटीएमएल विकल्प को एचटीएमएल कुंजी में लपेटा जाना चाहिए:

<%= form_with(model: @post, data: { behavior: "autosave" }, html: { name: "go" }) do |form| %>
  ...
<% end %>

उत्पन्न करता है

<form action="/posts/123" method="post" data-behavior="autosave" name="go">
  <input name="_method" type="hidden" value="patch" />
  ...
</form>

छिपी हुई मॉडल आईडी को हटाना

form_with पद्धति में मॉडल आईडी को प्रपत्र में छिपे हुए फ़ील्ड के रूप में स्वचालित रूप से शामिल किया गया है। इसका उपयोग प्रपत्र डेटा और उसके संबंधित मॉडल के बीच संबंध को बनाए रखने के लिए किया जाता है। कुछ ORM सिस्टम नेस्टेड मॉडल पर आईडी का उपयोग नहीं करते हैं इसलिए इस मामले में आप छिपी हुई आईडी को निष्क्रिय करने में सक्षम होना चाहते हैं।

निम्नलिखित उदाहरण में पोस्ट मॉडल में NoSQL डेटाबेस में कई टिप्पणियाँ संग्रहीत हैं, इस प्रकार टिप्पणियों के लिए कोई प्राथमिक कुंजी नहीं है।

<%= form_with(model: @post) do |form| %>
  <%= form.fields(:comments, skip_id: true) do |fields| %>
    ...
  <% end %>
<% end %>

अनुकूलित प्रपत्र बिल्डरों

आप स्वनिर्धारित FormBuilder वर्ग का उपयोग करके प्रपत्र भी बना सकते हैं। Subclass FormBuilder और ओवरराइड करें या कुछ और सहायकों को परिभाषित करें, फिर अपने कस्टम बिल्डर का उपयोग करें। उदाहरण के लिए, मान लें कि आपने इनपुट बनाने के लिए लेबलों को स्वचालित रूप से जोड़ने के लिए एक सहायक बनाया है।

<%= form_with model: @person, url: { action: "create" }, builder: LabellingFormBuilder do |form| %>
  <%= form.text_field :first_name %>
  <%= form.text_field :last_name %>
  <%= form.text_area :biography %>
  <%= form.check_box :admin %>
  <%= form.submit %>
<% end %>

इस मामले में, यदि आप उपयोग करते हैं:

<%= render form %>

प्रदान किया गया टेम्प्लेट people/_labelling_form और फार्म चर का संदर्भ देने वाले स्थानीय चर को labelling_form कहा जाता है।

जब तक यह स्पष्ट रूप से सेट नहीं किया जाता है तब तक कस्टम FormBuilder क्लास स्वचालित रूप से एक नेस्टेड fields कॉल के विकल्पों के साथ विलय कर दिया जाता है।

कई मामलों में आप ऊपर वाले को दूसरे सहायक में लपेटना चाहेंगे, इसलिए आप निम्नलिखित कुछ कर सकते हैं:

def labelled_form_with(**options, &block)
  form_with(**options.merge(builder: LabellingFormBuilder), &block)
end
Hidden_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1174
def hidden_field(object_name, method, options = {})
  Tags::HiddenField.new(object_name, method, self, options).render
end

एक निर्दिष्ट विशेषता ( method द्वारा पहचानी गई) तक पहुँचने के लिए एक छिपा हुआ इनपुट टैग लौटाता है जो टेम्पलेट को सौंपी गई object ( object द्वारा पहचाना गया) पर होता है। इनपुट टैग पर अतिरिक्त विकल्पों को options साथ हैश के रूप में पारित किया जा सकता है। इन विकल्पों को HTML में HTML तत्व विशेषता के रूप में दिखाया गया है जैसा कि दिखाया गया है।

उदाहरण

hidden_field(:signup, :pass_confirm)
# => <input type="hidden" id="signup_pass_confirm" name="signup[pass_confirm]" value="#{@signup.pass_confirm}" />

hidden_field(:post, :tag_list)
# => <input type="hidden" id="post_tag_list" name="post[tag_list]" value="#{@post.tag_list}" />

hidden_field(:user, :token)
# => <input type="hidden" id="user_token" name="user[token]" value="#{@user.token}" />
लेबल (object_name, विधि, content_or_options = nil, विकल्प = nil, & block) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1114
def label(object_name, method, content_or_options = nil, options = nil, &block)
  Tags::Label.new(object_name, method, self, content_or_options, options).render(&block)
end

किसी निर्दिष्ट विशेषता ( method द्वारा पहचानी गई) के लिए एक इनपुट फ़ील्ड लेबल करने के लिए सिलवाया गया टैग लेबल टेम्पलेट को सौंपी गई object ( object द्वारा पहचाना गया)। जब तक कोई अनुवाद वर्तमान I18n लोकेल (हेल्पर्स.लैबेल के माध्यम से। <मॉडलनाम> <विशेषता>) में पाया जाता है या आप इसे स्पष्ट रूप से निर्दिष्ट नहीं करते हैं, तब तक लेबल का पाठ डिफ़ॉल्ट होगा। लेबल टैग पर अतिरिक्त विकल्प विकल्पों के साथ हैश के रूप में पारित किया जा सकता है। इन विकल्पों को HTML में एक HTML तत्व विशेषता के रूप में दिखाया गया है, उदाहरण के लिए :value विकल्प के अलावा, जो #radio_button टैग के लिए लेबल को लक्षित करने के लिए डिज़ाइन किया गया है (जहां इनपुट टैग की आईडी में मान का उपयोग किया जाता है) ।

उदाहरण

label(:post, :title)
# => <label for="post_title">Title</label>

आप मॉडल और विशेषता नामों के आधार पर अपने लेबल को स्थानीय कर सकते हैं। उदाहरण के लिए आप अपने लोकेल में निम्नलिखित को परिभाषित कर सकते हैं (जैसे en.yml)

helpers:
  label:
    post:
      body: "Write your entire text here"

जिसके बाद में परिणाम होगा

label(:post, :body)
# => <label for="post_body">Write your entire text here</label>

स्थानीयकरण विशुद्ध रूप से विशेषता-नाम के अनुवाद पर आधारित हो सकता है (यदि आप ActiveRecord का उपयोग कर रहे हैं):

activerecord:
  attributes:
    post:
      cost: "Total cost"

label(:post, :cost)
# => <label for="post_cost">Total cost</label>

label(:post, :title, "A short title")
# => <label for="post_title">A short title</label>

label(:post, :title, "A short title", class: "title_label")
# => <label for="post_title" class="title_label">A short title</label>

label(:post, :privacy, "Public Post", value: "public")
# => <label for="post_privacy_public">Public Post</label>

label(:post, :terms) do
  raw('Accept <a href="/terms">Terms</a>.')
end
# => <label for="post_terms">Accept <a href="/terms">Terms</a>.</label>
month_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1465
def month_field(object_name, method, options = {})
  Tags::MonthField.new(object_name, method, self, options).render
end

"महीने" प्रकार का एक #text_field लौटाता है ।

month_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="month" />

डिफ़ॉल्ट मान कॉल करने के लिए कोशिश कर रहा द्वारा उत्पन्न होता है strftime वस्तु के मूल्य है, जो यह रूप में व्यवहार करते की घटनाओं के लिए की उम्मीद करता है पर "% Y-% m" DateTime और ActiveSupport::TimeWithZone

@user.born_on = Date.new(1984, 1, 27)
month_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="date" value="1984-01" />
number_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1508
def number_field(object_name, method, options = {})
  Tags::NumberField.new(object_name, method, self, options).render
end

"नंबर" प्रकार का इनपुट टैग देता है।

विकल्प

  • नंबर_फ़ील्ड_टैग के समान विकल्प स्वीकार करता है

password_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1156
def password_field(object_name, method, options = {})
  Tags::PasswordField.new(object_name, method, self, options).render
end

method टेम्पलेट (सौंपे गए ) को सौंपी गई वस्तु पर एक निर्दिष्ट विशेषता (द्वारा पहचाना गया ) तक पहुँचने के लिए "पासवर्ड" प्रकार का इनपुट टैग देता है object । इनपुट टैग पर अतिरिक्त विकल्पों को options साथ हैश के रूप में पारित किया जा सकता है। इन विकल्पों को HTML में HTML तत्व विशेषता के रूप में दिखाया गया है जैसा कि दिखाया गया है। सुरक्षा कारणों से यह फ़ील्ड डिफ़ॉल्ट रूप से रिक्त है; options यदि यह वांछित नहीं है, तो एक मूल्य के माध्यम से पास करें।

उदाहरण

password_field(:login, :pass, size: 20)
# => <input type="password" id="login_pass" name="login[pass]" size="20" />

password_field(:account, :secret, class: "form_input", value: @account.secret)
# => <input type="password" id="account_secret" name="account[secret]" value="#{@account.secret}" class="form_input" />

password_field(:user, :password, onchange: "if ($('#user_password').val().length > 30) { alert('Your password needs to be shorter!'); }")
# => <input type="password" id="user_password" name="user[password]" onchange="if ($('#user_password').val().length > 30) { alert('Your password needs to be shorter!'); }"/>

password_field(:account, :pin, size: 20, class: 'form_input')
# => <input type="password" id="account_pin" name="account[pin]" size="20" class="form_input" />
phone_field (object_name, विधि, विकल्प = {})

उपनाम #telephone_field

इसके लिए उपनाम: #telephone_field
Radio_button (object_name, विधि, tag_value, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1316
def radio_button(object_name, method, tag_value, options = {})
  Tags::RadioButton.new(object_name, method, self, tag_value, options).render
end

टेम्प्लेट को निर्दिष्ट ऑब्जेक्ट पर एक निर्दिष्ट विशेषता ( method द्वारा पहचाना गया) तक पहुँचने के लिए एक रेडियो बटन टैग देता है ( object द्वारा पहचाना गया)। यदि method का वर्तमान मान tag_value तो रेडियो बटन की जाँच की जाएगी।

रेडियो बटन को चेक पास करने के लिए बाध्य करने के लिए checked: true options में checked: true हैश। आप वहाँ भी HTML विकल्प पास कर सकते हैं।

# Let's say that @post.category returns "rails":
radio_button("post", "category", "rails")
radio_button("post", "category", "java")
# => <input type="radio" id="post_category_rails" name="post[category]" value="rails" checked="checked" />
#    <input type="radio" id="post_category_java" name="post[category]" value="java" />

# Let's say that @user.receive_newsletter returns "no":
radio_button("user", "receive_newsletter", "yes")
radio_button("user", "receive_newsletter", "no")
# => <input type="radio" id="user_receive_newsletter_yes" name="user[receive_newsletter]" value="yes" />
#    <input type="radio" id="user_receive_newsletter_no" name="user[receive_newsletter]" value="no" checked="checked" />
range_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1516
def range_field(object_name, method, options = {})
  Tags::RangeField.new(object_name, method, self, options).render
end

"रेंज" प्रकार का इनपुट टैग देता है।

विकल्प

  • रेंज_फ़ील्ड_टैग के समान विकल्प स्वीकार करता है

search_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1347
def search_field(object_name, method, options = {})
  Tags::SearchField.new(object_name, method, self, options).render
end

method टेम्पलेट को सौंपी गई वस्तु पर निर्दिष्ट विशेषता (द्वारा पहचानी गई ) तक पहुँचने के लिए "खोज" प्रकार का इनपुट लौटाता है object_name । "खोज" प्रकार के इनपुट कुछ ब्राउज़रों द्वारा अलग ढंग से स्टाइल किए जा सकते हैं।

search_field(:user, :name)
# => <input id="user_name" name="user[name]" type="search" />
search_field(:user, :name, autosave: false)
# => <input autosave="false" id="user_name" name="user[name]" type="search" />
search_field(:user, :name, results: 3)
# => <input id="user_name" name="user[name]" results="3" type="search" />
#  Assume request.host returns "www.example.com"
search_field(:user, :name, autosave: true)
# => <input autosave="com.example.www" id="user_name" name="user[name]" results="10" type="search" />
search_field(:user, :name, onsearch: true)
# => <input id="user_name" incremental="true" name="user[name]" onsearch="true" type="search" />
search_field(:user, :name, autosave: false, onsearch: true)
# => <input autosave="false" id="user_name" incremental="true" name="user[name]" onsearch="true" type="search" />
search_field(:user, :name, autosave: true, onsearch: true)
# => <input autosave="com.example.www" id="user_name" incremental="true" name="user[name]" onsearch="true" results="10" type="search" />
टेलीफ़ोन_फ़ील्ड (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1356
def telephone_field(object_name, method, options = {})
  Tags::TelField.new(object_name, method, self, options).render
end

"Tel" का #text_field लौटाता है ।

telephone_field("user", "phone")
# => <input id="user_phone" name="user[phone]" type="tel" />
इसके अलावा उपनाम: phone_field
text_area (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1234
def text_area(object_name, method, options = {})
  Tags::TextArea.new(object_name, method, self, options).render
end

method टेम्प्लेट खोलने और बंद करने वाले टैग को एक निर्दिष्ट विशेषता ( टेम्पलेट द्वारा पहचानी गई वस्तु) पर निर्दिष्ट विशेषता तक पहुँचने के लिए तैयार किया गया है object । इनपुट टैग पर अतिरिक्त विकल्पों को options साथ हैश के रूप में पारित किया जा सकता है।

उदाहरण

text_area(:post, :body, cols: 20, rows: 40)
# => <textarea cols="20" rows="40" id="post_body" name="post[body]">
#      #{@post.body}
#    </textarea>

text_area(:comment, :text, size: "20x30")
# => <textarea cols="20" rows="30" id="comment_text" name="comment[text]">
#      #{@comment.text}
#    </textarea>

text_area(:application, :notes, cols: 40, rows: 15, class: 'app_input')
# => <textarea cols="40" rows="15" id="application_notes" name="application[notes]" class="app_input">
#      #{@application.notes}
#    </textarea>

text_area(:entry, :body, size: "20x20", disabled: 'disabled')
# => <textarea cols="20" rows="20" id="entry_body" name="entry[body]" disabled="disabled">
#      #{@entry.body}
#    </textarea>
text_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1135
def text_field(object_name, method, options = {})
  Tags::TextField.new(object_name, method, self, options).render
end

method टेम्प्लेट (पहचाने गए object ) को सौंपी गई वस्तु पर एक निर्दिष्ट विशेषता (द्वारा पहचाना गया ) तक पहुँचने के लिए "पाठ" प्रकार का एक इनपुट टैग देता है । इनपुट टैग पर अतिरिक्त विकल्पों को options साथ हैश के रूप में पारित किया जा सकता है। इन विकल्पों को HTML में HTML तत्व विशेषता के रूप में दिखाया गया है जैसा कि दिखाया गया है।

उदाहरण

text_field(:post, :title, size: 20)
# => <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}" />

text_field(:post, :title, class: "create_input")
# => <input type="text" id="post_title" name="post[title]" value="#{@post.title}" class="create_input" />

text_field(:session, :user, onchange: "if ($('#session_user').val() === 'admin') { alert('Your login cannot be admin!'); }")
# => <input type="text" id="session_user" name="session[user]" value="#{@session.user}" onchange="if ($('#session_user').val() === 'admin') { alert('Your login cannot be admin!'); }"/>

text_field(:snippet, :code, size: 20, class: 'code_input')
# => <input type="text" id="snippet_code" name="snippet[code]" size="20" value="#{@snippet.code}" class="code_input" />
time_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1417
def time_field(object_name, method, options = {})
  Tags::TimeField.new(object_name, method, self, options).render
end

प्रकार "समय" का एक #text_field लौटाता है ।

डिफ़ॉल्ट मान strftime ऑब्जेक्ट के मान पर "% T.% L" के साथ कॉल करने के लिए उत्पन्न होता है । यह "मूल्य" विकल्प को पारित करके अभी भी ओवरराइड करना संभव है।

विकल्प

  • Time_field_tag ​​के समान विकल्प स्वीकार करता है

उदाहरण

time_field("task", "started_at")
# => <input id="task_started_at" name="task[started_at]" type="time" />

आप Date और Time उदाहरणों को पास करके "मिनट" और "अधिकतम" विशेषताओं के लिए मान बना सकते हैं ।

time_field("task", "started_at", min: Time.now)
# => <input id="task_started_at" name="task[started_at]" type="time" min="01:00:00.000" />

वैकल्पिक रूप से, आप "मिनट" और "अधिकतम" के मूल्यों के रूप में ISO8601 समय के रूप में एक String स्वरूपित पास कर सकते हैं ।

time_field("task", "started_at", min: "01:00:00")
# => <input id="task_started_at" name="task[started_at]" type="time" min="01:00:00.000" />
url_field (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1491
def url_field(object_name, method, options = {})
  Tags::UrlField.new(object_name, method, self, options).render
end

"Url" प्रकार का एक #text_field लौटाता है ।

url_field("user", "homepage")
# => <input id="user_homepage" name="user[homepage]" type="url" />
सप्ताह_क्षेत्र (object_name, विधि, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/form_helper.rb, line 1482
def week_field(object_name, method, options = {})
  Tags::WeekField.new(object_name, method, self, options).render
end

"सप्ताह" प्रकार का एक #text_field लौटाता है ।

week_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="week" />

डिफ़ॉल्ट मान कॉल करने के लिए कोशिश कर रहा द्वारा उत्पन्न होता है strftime वस्तु के मूल्य पर "% YW% डब्ल्यू" है, जो यह रूप में व्यवहार करते की घटनाओं के लिए की उम्मीद करता है के साथ DateTime और ActiveSupport::TimeWithZone

@user.born_on = Date.new(1984, 5, 12)
week_field("user", "born_on")
# => <input id="user_born_on" name="user[born_on]" type="date" value="1984-W19" />

Original text