---
title: "Ag obair le foirmeacha"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/topics/forms/
canonical: https://djangodocs.dev/ga/6.0/topics/forms/
---
# Ag obair le foirmeacha

> **Maidir leis an doiciméad seo**
>
> Soláthraíonn an doiciméad seo réamhrá ar buneilimintí na bhfoirmeacha gréasáin agus conas a láimhseálfar iad i Django Chun breathnú níos mionsonraithe ar réimsí sonracha de API na bhfoirmeacha, féach:doc: /ref/forms/api, :doc: /ref/forms/fields, agus:doc: /ref/forms/validation.

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.

Solá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

## Foirmeacha HTML

\<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í.

Tá 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.

Chomh maith lena eilimintí \<input\>\`\`\`, ní mór do fhoirm dhá rud a shonrú:

- *á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 \`\`

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.

I 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.

Ba 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.

Bheadh 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/\>.

Ar 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.

## Ról Django i bhfoirmeacha

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ó

Is 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

Láimhseálann Django trí chuid ar leith den obair a bhaineann le foirmeacha:

- sonraí 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.

## Foirmeacha i Django

Tá 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.

I 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.

### An rang Django: Class: Form

I 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.

Ar 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.)

Is 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.

Lé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á.

### Foirmeacha a thionscnamh, a phróiseáil agus a rindreáil

Agus réad á rindreáil i Django, is ginearálta déanaimid:

1. faigh greim air sa radharc (faigh ón mbunachar sonraí é, mar shampla)
2. cuir chuig comhthéacs an teimpléid é
3. é 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.

I 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ú.

Mar 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.

Nuair 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:

- sonraí ó 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.

## Foirm a thógáil

### An obair is gá a dhéanamh

Cuir 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:

```html+django
<form action="/your-name/" method="post">
    <label for="your_name">Your name: </label>
    <input id="your_name" type="text" name="your_name" value="{{ current_name }}">
    <input type="submit" value="OK">
</form>
```

Insí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í.

Anois 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

B'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.

Ag 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.

### Foirm a thógáil i Django

#### An rang: aicme: Foirm

Tá 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:

*`foirme.py`*

```python
from django import forms

class NameForm(forms.Form):
    your_name = forms.CharField(label="Your name", max_length=100)
```

Sainmhí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`](/ga/6.0/ref/forms/api/#django.forms.Form) instance has an [`is_valid()`](/ga/6.0/ref/forms/api/#django.forms.Form.is_valid) method, which runs
validation routines for all its fields. When this method is called, if all
fields 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:

```html+django
<label for="your_name">Your name: </label>
<input id="your_name" type="text" name="your_name" maxlength="100" required>
```

Tabhair 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.

#### An radharc

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.

Chun 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 í:

*`views.py`*

```python
from django.http import HttpResponseRedirect
from django.shortcuts import render

from .forms import NameForm

def get_name(request):
    # if this is a POST request we need to process the form data
    if request.method == "POST":
        # create a form instance and populate it with data from the request:
        form = NameForm(request.POST)
        # check whether it's valid:
        if form.is_valid():
            # process the data in form.cleaned_data as required
            # ...
            # redirect to a new URL:
            return HttpResponseRedirect("/thanks/")

    # if a GET (or any other method) we'll create a blank form
    else:
        form = NameForm()

    return render(request, "name.html", {"form": form})
```

Má 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.

Má 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

#### An teimpléad

Ní gá dúinn mórán a dhéanamh inár dteimpléad `name.html`:

```html+django
<form action="/your-name/" method="post">
    {% csrf_token %}
    {{ form }}
    <input type="submit" value="Submit">
</form>
```

Dé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.

> **Foirmeacha agus Iarratas ar Trasláithreán Cosaint ar Fhol**
>
> Seolann Django le cosaint éasca le húsáid:doc: cosaint i gcoinne Forgeasaithe Iarratais Tras-Láithreach' \</ref/csrf\>. Nuair a chuirtear foirm isteach trí \`POST \`\`le cosaint CSRF cumasaithe ní mór duit an chlib teimpléad:ttag: \`csrf\_token a úsáid mar atá sa sampla roimhe seo. Mar sin féin, ós rud é nach bhfuil cosaint CSRF ceangailte go díreach le foirmeacha i dteimpléid, fágtar an chlib seo as na samplaí seo a leanas sa doiciméad seo.

> **Cineálacha ionchuir HTML5 agus bailíochtú brabh**
>
> Má chuimsíonn d'fhoirm a:class: ~django.forms.URLField, an:class: ~django.forms.emailField nó aon chineál réimse sláireach, úsáidfidh Django na cineálacha ionchuir ```url ``, `email``` agus `Number` HTML5. De réir réamhshocraithe, féadfaidh brabhsálaithe a bhailíochtú féin a chur i bhfeidhm ar na réimsí seo, a d'fhéadfadh a bheith níos déine ná bailíochtú Django. Más mian leat an t-iompar seo a dhíchumasú, socraigh an tréith `novalidate` ar an gclib foirm , nó sonraigh giuirléid dhifriúil ar an réimse, cosúil:class: textInput.

\<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 .

Sin 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.

## Tuilleadh faoi ranganna Django:Class: Form

Cruthaí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.

> **Múnlaí agus Foirmeacha**
>
> Déanta na fírinne má úsáidfear d'fhoirm chun samhail Django a chur leis nó a chur in eagar go díreach, is féidir le a:doc: ModelForm go leor ama, iarrachta agus cód a shábháil duit, toisc go dtógfaidh sé foirm, mar aon leis na réimsí cuí \</topics/forms/modelforms\> agus a gcuid tréithe, ó rang Samhail .

### Cásanna foirmeacha ceangailte agus gan cheangal

Tá an t-idirdhealú idir: ref: ref-forms-api-bound-unbord tábhachtach:

- Ní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.

### Tuilleadh ar réimsí

Smaoinigh 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:

*`foirme.py`*

```python
from django import forms

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField(widget=forms.Textarea)
    contact_email = forms.EmailField()
    urgent = forms.BooleanField(required=False)
```

Our earlier form used a single field, `your_name`, a [`CharField`](/ga/6.0/ref/forms/fields/#django.forms.CharField). In
this case, our form has four fields: `subject`, `message`,
`contact_email` and `urgent`. [`CharField`](/ga/6.0/ref/forms/fields/#django.forms.CharField), [`EmailField`](/ga/6.0/ref/forms/fields/#django.forms.EmailField) and
[`BooleanField`](/ga/6.0/ref/forms/fields/#django.forms.BooleanField) are just three of the available field types; a full list
can be found in [Réimsí foirm](/ga/6.0/ref/forms/fields/).

#### Giuirléidí

\</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 .

I 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 .

#### Sonraí réimse

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.

> **Note**
>
> Is féidir leat rochtain a fháil ar na sonraí neamhbhailíochtaithe go díreach ó `Request.post` ag an bpointe seo, ach tá na sonraí bailíochtaithe níos fearr.

In the contact form example above, `urgent` will be a boolean value.
Likewise, fields such as [`IntegerField`](/ga/6.0/ref/forms/fields/#django.forms.IntegerField) and [`FloatField`](/ga/6.0/ref/forms/fields/#django.forms.FloatField) convert
values 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:

*`views.py`*

```python
from django.core.mail import EmailMessage

if form.is_valid():
    subject = form.cleaned_data["subject"]
    message = form.cleaned_data["message"]
    contact_email = form.cleaned_data["contact_email"]
    urgent = form.cleaned_data["urgent"]

    body = (
        "Submitted through the contact form.\n"
        f"Contact email (unverified): {contact_email}\n"
        f"Marked urgent: {'yes' if urgent else 'no'}\n"
        f"Message:\n{message}"
    )

    # Send the message, directing replies to the contact_email.
    EmailMessage(
        subject=f"[contact form] {subject}",
        body=body,
        from_email="contact-form@example.com",
        to=["info@example.com"],
        headers={"Importance": "high"} if urgent else None,
        reply_to=[contact_email],
    ).send()

    return HttpResponseRedirect("/thanks/")
```

> **Tip**
>
> Le haghaidh tuilleadh faoi ríomhphost a sheoladh ó Django, féach: doc: /topics/email.

Teastaí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.

## Ag obair le teimpléid fhoir

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í.

> **Troscán teimpléad foirm bh**
>
> Ná déan dearmad go gcuimsíonn aschur foirme\*ní\* na clibeanna máguaird\<form\>, nó rialú aighneacht' na foirme. Beidh ort iad seo a sholáthar duit féin.

### Teimpléid foirme in-ath

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.

Mar thoradh ar an sampla thíos beidh `{{form}}` a rinneadh mar aschur an teimpléad `form_snippet.html`.

I do theimpléid:

```html+django
# In your template:
{{ form }}

# In form_snippet.html:
{% for field in form %}
    <div class="fieldWrapper">
        {{ field.errors }}
        {{ field.label_tag }} {{ field }}
    </div>
{% endfor %}
```

Ansin is féidir leat an socrú: setting: FORM\_RENDER a chumrú:

*`settings.py`*

```python
from django.forms.renderers import TemplatesSetting

class CustomFormRenderer(TemplatesSetting):
    form_template_name = "form_snippet.html"

FORM_RENDERER = "project.settings.CustomFormRenderer"
```

... nó le haghaidh foirm amháin:

```
class MyForm(forms.Form):
    template_name = "form_snippet.html"
    ...
```

... 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:

```
def index(request):
    form = MyForm()
    rendered_form = form.render("form_snippet.html")
    context = {"form": rendered_form}
    return render(request, "index.html", context)
```

Féach:ref: ref-forms-api-outputting-html le haghaidh tuilleadh sonraí.

### Teimpléid grúpa allamuigh

Each field is available as an attribute of the form, using
`{{ form.name_of_field }}` in a template. A field has an
[`as_field_group()`](/ga/6.0/ref/forms/api/#django.forms.BoundField.as_field_group) method which renders the
related elements of the field as a group: its label, widget, errors, and help
text.

This allows generic templates to be written that arrange each field's elements
in the required layout. For example:

```html+django
{{ form.non_field_errors }}
<div class="fieldWrapper">
  {{ form.subject.as_field_group }}
</div>
<div class="fieldWrapper">
  {{ form.message.as_field_group }}
</div>
<div class="fieldWrapper">
  {{ form.contact_email.as_field_group }}
</div>
<div class="fieldWrapper">
  {{ form.urgent.as_field_group }}
</div>
```

De 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:

```
from django.forms.renderers import TemplatesSetting

class CustomFormRenderer(TemplatesSetting):
    field_template_name = "field_snippet.html"
```

... nó ar réimse amháin:

```
class MyForm(forms.Form):
    subject = forms.CharField(template_name="my_custom_template.html")
    ...
```

... nó ar bhonn in aghaidh iarratais trí ghlaoch ar :meth: .boundfield.render agus ainm teimpléad a sholáthar:

```
def index(request):
    form = ContactForm()
    subject = form["subject"]
    context = {"subject": subject.render("my_custom_template.html")}
    return render(request, "index.html", context)
```

### Réimsí rindreála de láimh

Is 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:

```html+django
{{ form.non_field_errors }}
<div class="fieldWrapper">
    {{ form.subject.errors }}
    <label for="{{ form.subject.id_for_label }}">Email subject:</label>
    {{ form.subject }}
</div>
<div class="fieldWrapper">
    {{ form.message.errors }}
    <label for="{{ form.message.id_for_label }}">Your message:</label>
    {{ form.message }}
</div>
<div class="fieldWrapper">
    {{ form.contact_email.errors }}
    <label for="{{ form.contact_email.id_for_label }}">Your email address:</label>
    {{ form.contact_email }}
</div>
<div class="fieldWrapper">
    {{ form.urgent.errors }}
    <label for="{{ form.urgent.id_for_label }}">Urgent reply needed?</label>
    {{ form.urgent }}
</div>
```

Is féidir eilimintí iomlána \<label\>\`\`\`a ghiniúint freisin ag baint úsáide as an: meth: ~django.forms.boundfield.label\_tag. Mar shampla:

```html+django
<div class="fieldWrapper">
    {{ form.subject.errors }}
    {{ form.subject.label_tag }}
    {{ form.subject }}
</div>
```

#### Teachtaireachtaí earráide foirm

Is é 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:

```html+django
<ul class="errorlist">
    <li>Contact email is required.</li>
</ul>
```

Tá 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:

```html+django
{% if form.subject.errors %}
    <ol>
    {% for error in form.subject.errors %}
        <li><strong>{{ error|escape }}</strong></li>
    {% endfor %}
    </ol>
{% endif %}
```

Dé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}} :

```html+django
<ul class="errorlist nonfield">
    <li>Generic validation error</li>
</ul>
```

Féach: doc: /ref/forms/api le haghaidh tuilleadh eolais faoi earráidí, stíliú, agus oibriú le tréithe foirme i dteimpléid.

### Lúpáil thar réimsí na foirme

Má 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%}`:

```html+django
{% for field in form %}
    <div class="fieldWrapper">
        {{ field.errors }}
        {{ field.label_tag }} {{ field }}
        {% if field.help_text %}
          <p class="help" id="{{ field.auto_id }}_helptext">
            {{ field.help_text|safe }}
          </p>
        {% endif %}
    </div>
{% endfor %}
```

I 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.

**`{{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.

**`{{field.id_for_label}}`**

  The ID that will be used for this field (`id_contact_email` in the
  example above). If you are constructing the label manually, you may want to
  use this in lieu of `label_tag`. It's also useful, for example, if you
  have 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:

```html+django
{% if field.is_hidden %}
   {# Do something special #}
{% endif %}
```

**`{{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:

  ```html+django
  <label for="id_contact_email">Contact email:</label>
  ```

**`{{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:

```html+django
{% if field.use_fieldset %}
  <fieldset>
  {% if field.label %}{{ field.legend_tag }}{% endif %}
{% else %}
  {% if field.label %}{{ field.label_tag }}{% endif %}
{% endif %}
{{ field }}
{% if field.use_fieldset %}</fieldset>{% endif %}
```

**`{{field.value}}`**

  Luach an réimse. m.sh. `someone@example.com`.

> **See also**
>
> Le haghaidh liosta iomlán tréithe agus modhanna, féach:class: ~django.forms.BoundField.

#### Lúpáil thar réimsí folaithe agus infheicthe

Má tá foirm ag leagan amach de láimh i dteimpl \<input type="hidden"\>éad, seachas brath ar leagan amach foirme réamhshocraithe Django, b'fhéidir gur mhaith leat réimsí a chóireáil go difriúil ó réimsí neamh-bhfolach. Mar shampla, toisc nach dtaispeánann réimsí i bhfolach aon rud, d'fhéadfadh teachtaireachtaí earráide a chur “in aice leis” an réimse mearbhall a bheith ina chúis le d'úsáideoirí - mar sin ba chóir earráidí do na réimsí sin a láimhseáil

Soláthraíonn Django dhá mhodh ar fhoirm a ligeann duit lúb thar na réimsí folaithe agus infheicthe go neamhspleách: ```hidden_fields () ``agus ``visible_fields ()```. Seo modhnú ar shampla níos luaithe a úsáideann an dá mhodh seo:

```html+django
{# Include the hidden fields #}
{% for hidden in form.hidden_fields %}
{{ hidden }}
{% endfor %}
{# Include the visible fields #}
{% for field in form.visible_fields %}
    <div class="fieldWrapper">
        {{ field.errors }}
        {{ field.label_tag }} {{ field }}
    </div>
{% endfor %}
```

Ní láimhseálann an sampla seo aon earráidí sna réimsí i bhfolach. De ghnáth, is comhartha é earráid i réimse i bhfolach i gceist, ós rud é nach n-athróidh gnáthidirghníomhú foirme iad. Mar sin féin, d'fhéadfá roinnt taispeántais earráide a chur isteach go héasca do na hearráidí foirme sin, freisin.

## Ábhar breise

Clúdaíonn sé seo na buneilimintí, ach is féidir le foirmeacha a lán níos mó a dhéanamh:

- [Foirmeacha](/ga/6.0/topics/forms/formsets/)

  - [Sonraí tosaigh a úsáid le tacar foirme](/ga/6.0/topics/forms/formsets/#using-initial-data-with-a-formset)
  - [An líon uasta na bhfoirmeacha a theorannú](/ga/6.0/topics/forms/formsets/#limiting-the-maximum-number-of-forms)
  - [Uaslíon na bhfoirmeacha ionchasacha a theorannú](/ga/6.0/topics/forms/formsets/#limiting-the-maximum-number-of-instantiated-forms)
  - [Bailíochtú Formset](/ga/6.0/topics/forms/formsets/#formset-validation)
  - [Líon na bhfoirmeacha i dtacar foirmeacha a bhailíochtú](/ga/6.0/topics/forms/formsets/#validating-the-number-of-forms-in-a-formset)
  - [Déileáil le foirmeacha a ordú agus a scriosadh](/ga/6.0/topics/forms/formsets/#dealing-with-ordering-and-deletion-of-forms)
  - [Réimsí breise a chur le tacar foirmeacha](/ga/6.0/topics/forms/formsets/#adding-additional-fields-to-a-formset)
  - [Ag dul paraiméadair saincheaptha chuig foirmeacha](/ga/6.0/topics/forms/formsets/#passing-custom-parameters-to-formset-forms)
  - [Réimír foirmshraith a shaincheapadh](/ga/6.0/topics/forms/formsets/#customizing-a-formset-s-prefix)
  - [Foirmshraith a úsáid i radhairc agus teimpléid](/ga/6.0/topics/forms/formsets/#using-a-formset-in-views-and-templates)
- [Foirmeacha a chruthú ó shamhl](/ga/6.0/topics/forms/modelforms/)

  - [`Samhlfhoirme`](/ga/6.0/topics/forms/modelforms/#modelform)
  - [Foirmeacha múnla](/ga/6.0/topics/forms/modelforms/#model-formsets)
  - [Foirmeacha inlíne](/ga/6.0/topics/forms/modelforms/#inline-formsets)
- [Sócmhainní Foirm (an aicme \`\`Meáin \`\`)](/ga/6.0/topics/forms/media/)

  - [Sócmhainní mar shainiú statach](/ga/6.0/topics/forms/media/#assets-as-a-static-definition)
  - [\`\`Meáin \`\`mar mhaoin dinimiciúil](/ga/6.0/topics/forms/media/#media-as-a-dynamic-property)
  - [Cosáin i sainmhínithe sócmh](/ga/6.0/topics/forms/media/#paths-in-asset-definitions)
  - [Rudaí \`\`Meáin \`\`](/ga/6.0/topics/forms/media/#media-objects)
  - [\`\`Meáin \`\`ar Fhoirmeacha](/ga/6.0/topics/forms/media/#media-on-forms)

> **See also**
>
> **[The Forms Reference](/ga/6.0/ref/forms/)**
>
>   Clúdaíonn sé an tagairt iomlán API, lena n-áirítear réimsí foirme, giuirléidí foirme, agus bailíochtú foirm agus all