Mura bhfuil tú ag pleanáil láithreáin ghréasáin agus feidhmchláir a thógáil nach ndéanann aon rud ach ábhar a fhoilsiú, agus nach nglacann sé le hionchur ó do chuairteoirí, beidh ort foirmeacha a thuiscint agus a úsáid.
\nSoláthraíonn Django raon uirlisí agus leabharlanna chun cabhrú leat foirmeacha a thógáil chun glacadh le hionchur ó chuairteoirí an láithreáin, agus ansin an t-ionchur a phróiseáil agus
\n<form>I HTML, is bailiúchán eilimintí é foirm taobh istigh de ``...</form> ``a ligeann do chuairteoir rudaí a dhéanamh mar téacs a iontráil, roghanna a roghnú, rudaí nó rialuithe a ionramháil, agus mar sin de, agus ansin an fhaisnéis sin a sheoladh ar ais chuig an bhfreastalaí.
\nTá cuid de na heilimintí comhéadain foirme seo - ionchur téacs nó boscaí seiceála - tógtha isteach i HTML féin. Tá daoine eile i bhfad níos casta; de ghnáth úsáidfidh comhéadan a chuireann roghnóir dáta suas nó a ligeann duit sleamhnán a bhogadh nó rialuithe a ionramháil JavaScript agus CSS chomh maith le heilimintí foirme HTML <input>```chun na héifeachtaí seo a bhaint amach.
\nChomh maith lena eilimintí <input>```, ní mór do fhoirm dhá rud a shonrú:
\náite: an URL ar chóir na sonraí a fhreagraíonn d'ionchur an úsáideora a thabhairt ar ais
how: the HTTP method the data should be returned by
Mar shampla, tá roinnt eilimintí `sa fhoirm logála isteach do riarachán Django<input>: ceann de ``type="text" don ainm úsáideora, ceann de type="password" don phasfhocal, agus ceann de type="submit" don chnaipe “Logáil isteach”. Tá roinnt réimsí téacs i bhfolach ann freisin nach bhfeiceann an t-úsáideoir, a úsáideann Django chun a chinneadh cad atá le déanamh ina dhiaidh sin.
Insíonn sé leis an mbrabhsálaí freisin gur chóir na sonraí foirme a sheoladh chuig an URL a sh <form>onraítear sa tréith ```` ```` ```` ```` - /admin/` - agus gur chóir iad a sheoladh ag baint úsáide as an meicníocht HTTP a shonraítear leis an tréith modh - post `.
Nuair a spreagtar an eilim <input type="submit" value="Log in">int `, cuirtear na sonraí ar ais chuig ``/admin/.
GET agus ``POST ``Link to this heading#Is iad GET agus `POST ``na modhanna HTTP amháin atá le húsáid agus tú ag déileáil le foirmeacha.
Cuirtear foirm logála isteach Django ar ais ag baint úsáide as an modh POST `, ina ndéanann an brabhsálaí sonraí na bhfoirme suas, iad a ionchódú lena tharchur, seolann sé chuig an bhfreastalaí, agus ansin faigheann sé a fhreagra ar ais.
\nI gcodarsnacht leis sin, cuireann GET` na sonraí curtha isteach i sreang, agus úsáideann sé seo chun URL a chumadh. Tá an seoladh san URL ina gcaithfear na sonraí a sheoladh, chomh maith leis na heochracha agus na luachanna sonraí. Is féidir leat é seo a fheiceáil i ngníomh má dhéanann tú cuardach sa dhoiciméadú Django, a tháirgfidh URL den fhoirm https://docs.djangoproject.com/search/?q=forms&release=1.
Is gnách go n-úsáidtear GET` agus `POST ``chun críocha éagsúla.
\nBa chóir d'aon iarratas a d'fhéadfaí a úsáid chun staid an chórais a athrú - mar shampla, iarratas a dhéanann athruithe sa bhunachar sonraí - `POST ``a úsáid. Níor chóir `GET ``a úsáid ach amháin le haghaidh iarratais nach ndéanann difear do staid an chórais.
\nBheadh GET ``mí-oiriúnach freisin d'fhoirm pasfhocal, toisc go mbeadh an pasfhocal le feiceáil sa URL, agus dá bhrí sin, i stair an bhrabhsálaí agus i logaí freastalaí, go léir i dtéacs simplí. Ní bheadh sé oiriúnach do chainníochtaí móra sonraí, nó do shonraí dénártha, mar shampla íomhá. Is riosca slándála é feidhmchlár gréasáin a úsáideann iarratais `GET ``ar fhoirmeacha riaracháin: is féidir go mbeadh sé éasca d'ionsaitheoir aithris a dhéanamh ar iarratas foirme chun rochtain a fháil ar chodanna íogaire den chóras. Tugann ``POST `, in éineacht le cosaintí eile cosúil le Django: Doc: `Cosaint CSRF `níos mó smachta ar rochtain </ref/csrf/>.
\nAr an láimh eile, tá GET` oiriúnach do rudaí cosúil le foirm chuardaigh gréasáin, toisc gur féidir na URLanna a léiríonn iarratas GET a leabharmharcáil, a roinnt nó a athchur isteach go héasca.
Is gnó casta é foirmeacha láimhseála. Smaoinigh ar riarachán Django, áit a bhféadfadh go mbeadh gá go leor míreanna sonraí de roinnt cineálacha éagsúla a ullmhú le taispeáint i bhfoirm, a léiriú mar HTML, a chur in eagar ag baint úsáide as comhéadan áisiúil, filleadh ar ais chuig an bhfreastalaí, a bhailíochtú agus a ghlanadh, agus ansin a shábháil nó
\nIs féidir le feidhmiúlacht fhoirme Django codanna móra den obair seo a shimpliú agus a uathoibriú, agus féadann sé é a dhéanamh níos sábháilte freisin ná mar a bheadh mórchuid na ríomhchláraitheoirí in ann a dhéanamh sa chód a sc
\nLáimhseálann Django trí chuid ar leith den obair a bhaineann le foirmeacha:
\nsonraí a ullmhú agus a athstruchtúrú chun iad a dhéanamh réidh le rindreáil
foirmeacha HTML a chruthú do na sonraí
foirmeacha agus sonraí curtha isteach ón gcliant a fháil agus a phróiseáil
Is féidir aithe* cód a scríobh a dhéanann é seo go léir de láimh, ach is féidir le Django aire a thabhairt dó go léir duit.
\nTá cur síos déanta againn ar fhoirmeacha HTML go hachomair, ach níl HTML <form>```` ach cuid amháin den innealra a theastaíonn.
\nI gcomhthéacs iarratais gréasáin, d'fhéadfadh 'foirm' tagairt a dhéanamh don HTML sin ``<form>, nó don Django:Class: `Foirm a tháirgeann í, nó do na sonraí struchtúrtha ar ais nuair a chuirtear isteach í, nó don bhailiúchán oibre deireadh go deireadh na gcodanna seo.
\nI gcroílár an chórais comhpháirteanna seo tá rang Django's:Class: Form. Ar an mbealach céanna a dhéanann samhail Django cur síos ar struchtúr loighciúil réada, a iompar, agus an bealach a léirítear a chodanna dúinn, a: aicme: Foirm cur síos ar fhoirm agus socraíonn sé conas a oibríonn sé agus a fheictear.
\nAr bhealach cosúil le réimsí rang samhail a léarscáil go réimsí bunachar sonraí, léarscáil réimsí ranga foirme chuig eilimintí foirm HTML <input>```. (A: Aicme: Mapáil ModelForm `réimsí ranga samhail chuig eilimintí foirm HTML `` <input>trí a: class: `Form; seo a bhfuil riarachán Django bunaithe air.)
\nIs ranganna iad réimsí foirme iad féin; bainistíonn siad sonraí foirme agus déanann siad bailíochtú nuair a chuirtear foirm isteach. A: Aicme: Láimhseálann DateField agus a:class: FileField cineálacha an-éagsúla sonraí agus caithfidh siad rudaí éagsúla a dhéanamh leis.
\nLéirítear réimse foirme d'úsáideoir sa bhrabhsálaí mar “giuirléid” HTML - píosa innealra comhéadan úsáideora. Tá réamhshocrú cuí ag gach cineál réimse: doc: Aicme giuirléid, ach is féidir iad seo a shárú </ref/forms/widgets/> de réir mar is gá.
\nAgus réad á rindreáil i Django, is ginearálta déanaimid:
\nfaigh greim air sa radharc (faigh ón mbunachar sonraí é, mar shampla)
cuir chuig comhthéacs an teimpléid é
é a leathnú go marcáil HTML ag úsáid athróga teimpléad
Is éard atá i gceist le foirm a rindreáil i dteimpléad beagnach an obair chéanna le haon chineál réad eile a rindreáil, ach tá roinnt príomhdhifríochtaí ann.
\nI gcás samhail samhail nach raibh aon sonraí ann, is annamh a bheadh sé úsáideach riamh aon rud a dhéanamh leis i dteimpléad. Ar an láimh eile, bíonn ciall foirfe foirm neamhdhaonra a thabhairt - sin an rud a dhéanaimid nuair is mian linn go ndéanfadh an t-úsáideoir é a dhaonrú.
\nMar sin nuair a láimhseálann muid samhail samhail i radharc, is gnách go mbímid é a aisghabháil ón mbunachar sonraí. Nuair a bhíonn muid ag déileáil le foirm de ghnáth déanaimid í sa radharc.
\nNuair a dhéanaimid foirm a chruthú, is féidir linn a roghnú í a fhágáil folamh nó í a réamhdhíonrú, mar shampla le:
\nsonraí ó shampla samhail shábháilte (mar atá i gcás foirmeacha riaracháin le haghaidh eagarthóireachta)
sonraí atá curtha le chéile againn ó fhoinsí eile
sonraí a fuarthas ó aighneacht foirm HTML roimhe seo
Is é an ceann deireanach de na cásanna seo an ceann is suimiúla, toisc gurb é an rud a fhágann gur féidir d'úsáideoirí ní amháin láithreán gréasáin a léamh, ach faisnéis a sheoladh ar ais chuige freisin.
\nCuir i gcás gur mhaith leat foirm shimplí a chruthú ar do shuíomh Gréasáin, d'fhonn ainm an úsáideora a fháil. Bheadh rud éigin mar seo ag teastáil uait i do theimpléad:
\n<form action="/your-name/" method="post">\n <label for="your_name">Your name: </label>\n <input id="your_name" type="text" name="your_name" value="{{ current_name }}">\n <input type="submit" value="OK">\n</form>\nInsíonn sé seo don bhrabhsálaí sonraí na bhfoirme a thabhairt ar ais chuig an URL /your-ainm/, ag baint úsáide as an modh POST ``. Taispeánfaidh sé réimse téacs, lipéadaithe “Do ainm:”, agus cnaipe marcáilte “OK”. Má tá athróg ``current_name sa chomhthéacs teimpléid, úsáidfear é sin chun an réimse your_name réamh-líonadh.
Beidh amharc ag teastáil uait a léiríonn an teimpléad ina bhfuil an fhoirm HTML, agus is féidir leis an réimse current_name a sholáthar de réir mar is cuí.
Nuair a chuirtear an fhoirm isteach, beidh sonraí na foirme san iarratas ``POST ``a sheoltar chuig an bhfreastalaí.
\nAnois beidh radharc ag teastáil uait freisin a fhreagraíonn don URL /d'ainm/ sin a gheobhaidh na péirí eochair/luacha cuí san iarratas, agus ansin iad a phróiseáil.
Is foirm an-simplí é seo. Go praiticiúil, d'fhéadfadh go mbeadh mórán nó na céadta réimsí i bhfoirm, a d'fhéadfadh go mbeadh go leor acu a réamhdhaonrú, agus b'fhéidir go bhfuilimid ag súil go n-oibreoidh an t-úsáideoir tríd an timthriall eagarthóireach-chur isteach arís agus arís eile
\nB'fhéidir go mbeidh roinnt bailíochtaithe ag teastáil uainn sa bhrabhsálaí, fiú sula gcuirtear an fhoirm isteach; b'fhéidir gur mhaith linn réimsí i bhfad níos casta a úsáid, a ligeann don úsáideoir rudaí a dhéanamh cosúil le dátaí a roghnú ó fhéilire agus mar sin de.
\nAg an bpointe seo tá sé i bhfad níos éasca Django a fháil chun an chuid is mó den obair seo a dhéanamh dúinn.
\nTá a fhios againn cheana féin cén chuma atá againn ar ár bhfoirm HTML. Is é seo an pointe tosaigh atá againn dó i Django:
\nfoirme.pyfrom django import forms\n\n\nclass NameForm(forms.Form):\n your_name = forms.CharField(label="Your name", max_length=100)\nSainmhíníonn sé seo a: aicme: Foirm aicme le réimse amháin (your_name). Chuireamar lipéad atá cairdiúil don duine i bhfeidhm ar an réimse, a bheidh le feiceáil sa <label>```nuair a rinneofar é (cé sa chás seo, is é an:attr: ~field.label a shonraíomar an ceann céanna i ndáiríre a ghinteofaí go huathoibríoch dá bhfágfaimis é).
Sainmhínítear uasfhad incheadaithe an réimse ag: attr: ~charfield.max_Length. Déanann sé seo dhá rud. Cuireann sé maxlength ="100" ar an HTML <input> (mar sin ba chóir don bhrabhsálaí cosc ar an úsáideoir níos mó ná an líon sin carachtair a iontráil sa chéad áit). Ciallaíonn sé freisin nuair a fhaigheann Django an fhoirm ar ais ón mbrabhsálaí, go ndéanfaidh sé fad na sonraí a bhailíochtú.
A Form instance has an is_valid() method, which runs\nvalidation routines for all its fields. When this method is called, if all\nfields contain valid data, it will:
tuairisceán True
cuir sonraí na foirme ina tréith: attr: ~form.Cleaned_Data.
Beidh cuma ar an bhfoirm iomlán, nuair a rindreáiltear den chéad uair, mar seo a leanas:
\n<label for="your_name">Your name: </label>\n<input id="your_name" type="text" name="your_name" maxlength="100" required>\nTabhair faoi deara nach n-áirítear ion** na clibeanna <form>, nó cnaipe cuir isteach. Beidh orainn iad siúd féin a sholáthar sa teimpléad.
Déantar sonraí foirme a sheoltar ar ais chuig suíomh Gréasáin Django a phróiseáil le dearcadh, de ghnáth an dearcadh céanna a d'fhoilsigh an fhoirm Ligeann sé seo dúinn cuid den loighic chéanna a athúsáid.
\nChun an fhoirm a láimhseáil ní mór dúinn í a chur isteach sa radharc don URL áit ar mhaith linn go bhfoilsíodh í:
\nviews.pyfrom django.http import HttpResponseRedirect\nfrom django.shortcuts import render\n\nfrom .forms import NameForm\n\n\ndef get_name(request):\n # if this is a POST request we need to process the form data\n if request.method == "POST":\n # create a form instance and populate it with data from the request:\n form = NameForm(request.POST)\n # check whether it's valid:\n if form.is_valid():\n # process the data in form.cleaned_data as required\n # ...\n # redirect to a new URL:\n return HttpResponseRedirect("/thanks/")\n\n # if a GET (or any other method) we'll create a blank form\n else:\n form = NameForm()\n\n return render(request, "name.html", {"form": form})\nMá thagann muid ar an radharc seo le hiarratas ``GET ``, cruthóidh sé sampla foirme folamh agus cuirfidh sé i gcomhthéacs an teimpléid atá le léiriú. Seo an rud is féidir linn a bheith ag súil go dtarlóidh an chéad uair a thugaimid cuairt ar an URL.
\nMá chuirtear an fhoirm isteach ag baint úsáide as iarratas POST ``, cruthóidh an dearcadh sampla foirme arís agus líonfaidh sé le sonraí ón iarratas: ``form = AinmForm (request.post) Tugtar “sonraí ceangailteach leis an bhfoirm” air seo (foirme*teorann* í anois).
Glaoimid modh is_valid () ``ar an bhfoirm; mura bhfuil sé ``True, téimid ar ais chuig an teimpléad leis an bhfoirm. An uair seo níl an fhoirm folamh a thuilleadh (untheor) mar sin déanfar na sonraí a cuireadh isteach roimhe seo sa fhoirm HTML, áit ar féidir í a chur in eagar agus a cheartú de réir mar is gá.
Más é is_valid () ```True, beidh muid in ann anois na sonraí foirme bailíochtaithe go léir a fháil ina tréith cleaned_data. Is féidir linn na sonraí seo a úsáid chun an bunachar sonraí a nuashonrú nó próiseáil eile a dhéanamh sula seolfaimid atreorú HTTP chuig an mbrabhsálaí ag insint dó cá háit a rachaidh
Ní gá dúinn mórán a dhéanamh inár dteimpléad name.html:
<form action="/your-name/" method="post">\n {% csrf_token %}\n {{ form }}\n <input type="submit" value="Submit">\n</form>\nDéanfar réimsí uile na foirme agus a dtréithe a dhíphacáil isteach i marcáil HTML ón {{form}} sin ag teanga teimpléad Django.
<form>Tá foirm gréasáin oibre againn anois, a thuairiscítear ag Django: Class: Form, a phróiseáiltear ag radharc, agus a rindreáiltear mar HTML ```.
\nSin gach rud a theastaíonn uait chun tosú, ach cuireann creat na bhfoirmeacha i bhfad níos mó ar do mhéar. Nuair a thuigeann tú buneilimintí an phróisis a thuairiscítear thuas, ba chóir duit a bheith réidh chun gnéithe eile den chóras foirmeacha a thuiscint agus réidh chun beagán níos mó a fhoghlaim faoin innealra bunúsach.
\nCruthaítear gach rang foirme mar fho-aicmí de: aicme: django.forms.form nó:class: Django.Forms.ModelForm. Is féidir leat smaoineamh ar ModelForm mar fho-aicme de Form. Tá feidhmiúlacht choiteann ag Foirm ``agus `ModelForm i ndáiríre ó rang ``BaseForm ``(príobháideach), ach is annamh a bhíonn an mionsonraí cur chun feidhme seo tábhachtach.
Tá an t-idirdhealú idir: ref: ref-forms-api-bound-unbord tábhachtach:
\nNíl aon sonraí a bhaineann le foirm neamhcheangailte leis. Nuair a dhéanfar é don úsáideoir, beidh sé folamh nó beidh luachanna réamhshocraithe ann.
Tá sonraí curtha isteach ag foirm cheangailte, agus dá bhrí sin is féidir í a úsáid chun a rá an bhfuil na sonraí sin bailí. Má dhéantar foirm cheangailte neamhbhailí a léiriú, féadfaidh teachtaireachtaí earráide inlíne a áireamh ann ag insint don úsáideoir na sonraí
Inseoidh an tréith foirm 's:attr: ~form.is_bound duit an bhfuil sonraí ceangailte ag foirm nó nach bhfuil.
\nSmaoinigh ar fhoirm níos úsáideach ná ár sampla íosta thuas, a d'fhéadfaimis a úsáid chun feidhmiúlacht “déan teagmháil liom” a chur i bhfeidhm ar shuíomh Gréasáin pearsanta:
\nfoirme.pyfrom django import forms\n\n\nclass ContactForm(forms.Form):\n subject = forms.CharField(max_length=100)\n message = forms.CharField(widget=forms.Textarea)\n contact_email = forms.EmailField()\n urgent = forms.BooleanField(required=False)\nOur earlier form used a single field, your_name, a CharField. In\nthis case, our form has four fields: subject, message,\ncontact_email and urgent. CharField, EmailField and\nBooleanField are just three of the available field types; a full list\ncan be found in Réimsí foirm.
</ref/forms/widgets/> <input type="text">Tá comhfhreagrach ag gach réimse foirme: doc: Class giuirléid, a fhreagraíonn do ghuirléid fhoirme HTML mar ````.
\nI bhformhór na gcásanna, beidh giuirléid réamhshocraithe ciallmhar sa réimse <input type="text">Mar shampla, de réir réamhshocraithe, beidh a: class: textInput giuirléid ag a: class: Charfield, a tháirgeann ```` sa HTML. Más gá duit <textarea> ina ionad sin, shonrófá an giuirléid chuí agus do réimse foirme á shainiú agat, mar a rinneamar don réimse ``teachtaireacht ``.
Cibé na sonraí a chuirtear isteach le foirm, nuair a bheidh siad bailíochtaithe go rathúil trí ghlaoch ar is_valid () `(agus ``is_valid ()` tar éis ``True ar ais), beidh sonraí na bhfoirme bailíochtaithe sa fhoclóir form.cleaned_data. Déanfar na sonraí seo a thiontú go deas i gcineálacha Python duit.
In the contact form example above, urgent will be a boolean value.\nLikewise, fields such as IntegerField and FloatField convert\nvalues to a Python int and float respectively.
Seo conas a d'fhéadfaí na sonraí foirme a phróiseáil sa dearcadh a láimhseálann an fhoirm seo:
\nviews.pyfrom django.core.mail import EmailMessage\n\nif form.is_valid():\n subject = form.cleaned_data["subject"]\n message = form.cleaned_data["message"]\n contact_email = form.cleaned_data["contact_email"]\n urgent = form.cleaned_data["urgent"]\n\n body = (\n "Submitted through the contact form.\\n"\n f"Contact email (unverified): {contact_email}\\n"\n f"Marked urgent: {'yes' if urgent else 'no'}\\n"\n f"Message:\\n{message}"\n )\n\n # Send the message, directing replies to the contact_email.\n EmailMessage(\n subject=f"[contact form] {subject}",\n body=body,\n from_email="contact-form@example.com",\n to=["info@example.com"],\n headers={"Importance": "high"} if urgent else None,\n reply_to=[contact_email],\n ).send()\n\n return HttpResponseRedirect("/thanks/")\nTeastaíonn roinnt láimhseála breise ó roinnt cineálacha Mar shampla, ní mór comhaid a uaslódáiltear ag baint úsáide as foirm a láimhseáil ar bhealach difriúil (is féidir iad a aisghabháil ó Request.Files, seachas request.post). Le haghaidh sonraí maidir le conas uaslódálacha comhad a láimhseáil le d'fhoirm, féach:ref: binding-uploaded-files.
Níl le déanamh agat chun d'fhoirm a chur i dteimpléad ná an tsampla foirme a chur i gcomhthéacs an teimpléid. <label><input>Mar sin má thugtar foirm ``sa chomhthéacs ar d'fhoirm, déanfaidh {{form}} a eilimintí agus ```a ghnéithe go cuí.
Gintear an t-aschur HTML agus foirm á rindreáil air féin trí theimpléad. Is féidir leat é seo a rialú trí chomhad teimpléad iomchuí a chruthú agus saincheap:setting: FORM_RENDER a shocrú chun sean:attr: ~django.forms.renderers.baserenderer.form_template_name a úsáid ar fud an láithreáin. Is féidir leat foirm a shaincheapadh freisin tríd an tréith foirm 's:attr: ~django.forms.form.template_name a shárú chun an fhoirm a léiriú ag baint úsáide as an teimpléad saincheaptha, nó trí ainm an teimpléid a chur go díreach chuig:meth: .form.render.
\nMar thoradh ar an sampla thíos beidh {{form}} a rinneadh mar aschur an teimpléad form_snippet.html.
I do theimpléid:
\n# In your template:\n{{ form }}\n\n# In form_snippet.html:\n{% for field in form %}\n <div class="fieldWrapper">\n {{ field.errors }}\n {{ field.label_tag }} {{ field }}\n </div>\n{% endfor %}\nAnsin is féidir leat an socrú: setting: FORM_RENDER a chumrú:
\nsettings.pyfrom django.forms.renderers import TemplatesSetting\n\n\nclass CustomFormRenderer(TemplatesSetting):\n form_template_name = "form_snippet.html"\n\n\nFORM_RENDERER = "project.settings.CustomFormRenderer"\n... nó le haghaidh foirm amháin:
\nclass MyForm(forms.Form):\n template_name = "form_snippet.html"\n ...\n... nó le haghaidh rindreáil aonair de shampla foirme, ag cur isteach ainm an teimpléid chuig an:meth: .form.render. Seo sampla de seo a úsáidtear i radharc:
\ndef index(request):\n form = MyForm()\n rendered_form = form.render("form_snippet.html")\n context = {"form": rendered_form}\n return render(request, "index.html", context)\nFéach:ref: ref-forms-api-outputting-html le haghaidh tuilleadh sonraí.
\nEach field is available as an attribute of the form, using\n{{ form.name_of_field }} in a template. A field has an\nas_field_group() method which renders the\nrelated elements of the field as a group: its label, widget, errors, and help\ntext.
This allows generic templates to be written that arrange each field's elements\nin the required layout. For example:
\n{{ form.non_field_errors }}\n<div class="fieldWrapper">\n {{ form.subject.as_field_group }}\n</div>\n<div class="fieldWrapper">\n {{ form.message.as_field_group }}\n</div>\n<div class="fieldWrapper">\n {{ form.contact_email.as_field_group }}\n</div>\n<div class="fieldWrapper">\n {{ form.urgent.as_field_group }}\n</div>\nDe réir réamhshocraithe úsáideann Django an teimpléad ” django/forms/field.html “ atá deartha le húsáid leis an stíl foirme réamhshocraithe ” django/forms/div.html “.
Is féidir an teimpléad réamhshocraithe a shaincheapadh trí:attr: ~django.forms.renderers.baserenderer.field_template_name i do leibhéal tionscadail: setting: FORM_RENDER:
\nfrom django.forms.renderers import TemplatesSetting\n\n\nclass CustomFormRenderer(TemplatesSetting):\n field_template_name = "field_snippet.html"\n... nó ar réimse amháin:
\nclass MyForm(forms.Form):\n subject = forms.CharField(template_name="my_custom_template.html")\n ...\n... nó ar bhonn in aghaidh iarratais trí ghlaoch ar :meth: .boundfield.render agus ainm teimpléad a sholáthar:
\ndef index(request):\n form = ContactForm()\n subject = form["subject"]\n context = {"subject": subject.render("my_custom_template.html")}\n return render(request, "index.html", context)\nIs féidir rialú níos mó gránach ar rindreáil allamuigh a dhéanamh freisin. Is dócha go mbeidh sé seo i teimpléad réimse saincheaptha, chun ligean an teimpléad a scríobh uair amháin agus a athúsáid do gach réimse. Mar sin féin, is féidir rochtain a fháil go díreach air ón tréith allamuigh ar an bhfoirm. Mar shampla:
\n{{ form.non_field_errors }}\n<div class="fieldWrapper">\n {{ form.subject.errors }}\n <label for="{{ form.subject.id_for_label }}">Email subject:</label>\n {{ form.subject }}\n</div>\n<div class="fieldWrapper">\n {{ form.message.errors }}\n <label for="{{ form.message.id_for_label }}">Your message:</label>\n {{ form.message }}\n</div>\n<div class="fieldWrapper">\n {{ form.contact_email.errors }}\n <label for="{{ form.contact_email.id_for_label }}">Your email address:</label>\n {{ form.contact_email }}\n</div>\n<div class="fieldWrapper">\n {{ form.urgent.errors }}\n <label for="{{ form.urgent.id_for_label }}">Urgent reply needed?</label>\n {{ form.urgent }}\n</div>\nIs féidir eilimintí iomlána <label>```a ghiniúint freisin ag baint úsáide as an: meth: ~django.forms.boundfield.label_tag. Mar shampla:
\n<div class="fieldWrapper">\n {{ form.subject.errors }}\n {{ form.subject.label_tag }}\n {{ form.subject }}\n</div>\nIs é praghas na solúbthachta seo beagán níos mó oibre. Go dtí seo ní raibh orainn a bheith buartha faoi conas earráidí foirme a thaispeáint, mar tugadh aire dúinn sin. Sa sampla seo bhí orainn a chinntiú go dtugann muid aire d'aon earráidí do gach réimse agus d'aon earráidí don fhoirm ina iomláine. Tabhair faoi deara {{form.non_field_errors}} ag barr na foirme agus cuardaigh an teimpléad le haghaidh earráidí ar gach réimse.
Ag baint úsáide as {{form.name_of_field.errors}} taispeántar liosta earráidí foirme, a rinneadh mar liosta neamh-ordaithe. D'fhéadfadh sé seo a bheith cosúil le:
<ul class="errorlist">\n <li>Contact email is required.</li>\n</ul>\nTá aicme CSS de earrorlist ar an liosta chun ligean duit a chuma a stíleáil. Más mian leat taispeáint earráidí a shaincheapadh tuilleadh is féidir leat é sin a dhéanamh trí lúpáil orthu:
{% if form.subject.errors %}\n <ol>\n {% for error in form.subject.errors %}\n <li><strong>{{ error|escape }}</strong></li>\n {% endfor %}\n </ol>\n{% endif %}\nDéanfar earráidí neamh-réimse (agus/nó earráidí réimse i bhfolach a rinneadh ag barr na foirme nuair a úsáidtear cúntóirí cosúil le form.as_p () `) le rang breise ``neamh-réimse` chun cabhrú leo a idirdhealú ó earráidí réimsiúla. Mar shampla, bheadh cuma ``{{form.non_field_errors}} `:
\n<ul class="errorlist nonfield">\n <li>Generic validation error</li>\n</ul>\nFéach: doc: /ref/forms/api le haghaidh tuilleadh eolais faoi earráidí, stíliú, agus oibriú le tréithe foirme i dteimpléid.
\nMá tá an HTML céanna á úsáid agat do gach réimse foirme, is féidir leat cód dúblach a laghdú trí lúb {% for%} a úsáid trí lúb {% for%}:
{% for field in form %}\n <div class="fieldWrapper">\n {{ field.errors }}\n {{ field.label_tag }} {{ field }}\n {% if field.help_text %}\n <p class="help" id="{{ field.auto_id }}_helptext">\n {{ field.help_text|safe }}\n </p>\n {% endif %}\n </div>\n{% endfor %}\nI measc na dtréithe úsáideacha ar {{field}} tá:
{{field.errors}}Aschur <ul class="errorlist">```` ina bhfuil aon earráidí bailíochtaithe a fhreagraíonn don réimse seo. Is féidir leat cur i láthair na n-earráidí a shaincheapadh le lúb {% d'earráid in field.errors%}. Sa chás seo, is teaghrán é gach rud sa lúb ina bhfuil an teachtaireacht earráide.
{{field.field}}An sampla: Class: ~django.forms.field ón rang foirm a fhilleann seo:class: ~django.forms.boundfield. Is féidir leat é a úsáid chun rochtain a fháil ar: class: ~django.forms.field tréithe, m.sh. {{char_field.field.max_length}}.
{{field.help_text}}Aon téacs cabhrach a bhí bainteach leis an réimse.
\n{{field.html_name}}Ainm an réimse a úsáidfear i réimse ainm an eilimint ionchuir. Cuireann sé seo réimír an fhoirme san áireamh, má tá sé socraithe.
\n{{field.id_for_label}}The ID that will be used for this field (id_contact_email in the\nexample above). If you are constructing the label manually, you may want to\nuse this in lieu of label_tag. It's also useful, for example, if you\nhave some inline JavaScript and want to avoid hardcoding the field's ID.
{{field.is_hidden}}Is é an tréith seo True más réimse i bhfolach é an réimse foirme agus False a shlí eile. Níl sé úsáideach go háirithe mar athróg teimpléad, ach d'fhéadfadh sé a bheith úsáideach i dtástálacha coinníollach mar:
{% if field.is_hidden %}\n {# Do something special #}\n{% endif %}\n{{field.label}}The label of the field, e.g. Contact email.
{{field.label_tag}}Lipéad an réimse fillte sa chlib HTML <label>```` cuí. Áirítear leis seo an fhoirm 's:attr: ~django.forms.form.label_suffix. Mar shampla, is é an réamhshocraithe label_suffix colon:
<label for="id_contact_email">Contact email:</label>\n{{field.legend_tag}}<label><fieldset>Cosúil le field.label_tag ach úsáideann sé clib ```` <legend>in ionad ``, le haghaidh giuirléidí le hionchuir iolracha atá fillte i ``.
{{field.use_fieldset}}<legend>Is é an tréith seo True má tá ionchuir iolracha i ngiuirléid an réimse foirme ar chóir a ghrúpáil go séimeantach i ```` le <fieldset> chun inrochtaineacht a fheabhsú. Úsáid sampla i dteimpléad:
{% if field.use_fieldset %}\n <fieldset>\n {% if field.label %}{{ field.legend_tag }}{% endif %}\n{% else %}\n {% if field.label %}{{ field.label_tag }}{% endif %}\n{% endif %}\n{{ field }}\n{% if field.use_fieldset %}</fieldset>{% endif %}\n{{field.value}}Luach an réimse. m.sh. someone@example.com.
For a complete list of attributes and methods, see the reference guide for\nBoundField.
Clúdaíonn sé seo na buneilimintí, ach is féidir le foirmeacha a lán níos mó a dhéanamh:
\n