---
title: "Giuirléidí"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/ref/forms/widgets/
canonical: https://djangodocs.dev/ga/6.0/ref/forms/widgets/
---
# Giuirléidí

Is é giuirléid léiriú Django ar eilimint ionchuir HTML. Láimhseálann an giuirléid rindreáil an HTML, agus eastóscadh sonraí ó fhoclóir GET/POST a fhreagraíonn don ghuirléid.

Úsáideann an HTML a ghineann na giuirléidí ionsuite comhréir HTML5, ag díriú ar `<DOCTYPE html>`. Mar shampla, úsáideann sé tréithe boolean mar `checked` seachas an stíl XHTML de checked='checked'.

> **Tip**
>
> Níor chóir giuirléidí a mheascadh leis na:doc: réimsí foirmeacha \</ref/forms/fields\>. Déileálann réimsí foirme le loighic na bailíochtaithe ionchuir agus úsáidtear iad go díreach i dteimpl Déileálann giuirléidí le rindreáil eilimintí ionchuir foirme HTML ar an leathanach gréasáin agus eastóscadh sonraí amha curtha isteach. Mar sin féin, ní mór go mbeadh giuirléidí: ref: sannta \<widget-to-field\>\`chun réimsí a fhoirmiú.

## Giuirléidí a sh

Aon uair a shonraíonn tú réimse ar fhoirm, úsáidfidh Django giuirléid réamhshocraithe atá oiriúnach don chineál sonraí atá le taispeáint. Chun a fháil amach cén giuirléid a úsáidtear ar an réimse, féach an doiciméadú fao:ref: built-in-fields.

Mar sin féin, más mian leat giuirléid dhifriúil a úsáid le haghaidh réimse, is féidir leat an argóint:attr: ~field.widget a úsáid ar an sainmhíniú réimse. Mar shampla:

```
from django import forms

class CommentForm(forms.Form):
    name = forms.CharField()
    url = forms.URLField()
    comment = forms.CharField(widget=forms.Textarea)
```

Sonródh sé seo foirm le trácht a úsáideann giuirléid níos mó: class: Textarea, seachas an giuirléid réamhshocraithe:class: TextInput.

## Argóintí a leagan síos le haghaidh

Tá argóintí breise roghnacha ag go leor giuirléidí; is féidir iad a shocrú agus an giuirléid ar an réimse á shain Sa sampla seo a leanas, socraítear tréith an:attr: ~django.forms.selectDateWidget.years le haghaidh a:class: ~django.forms.selectDateWidget:

```
from django import forms

BIRTH_YEAR_CHOICES = ["1980", "1981", "1982"]
FAVORITE_COLORS_CHOICES = {
    "blue": "Blue",
    "green": "Green",
    "black": "Black",
}

class SimpleForm(forms.Form):
    birth_year = forms.DateField(
        widget=forms.SelectDateWidget(years=BIRTH_YEAR_CHOICES)
    )
    favorite_colors = forms.MultipleChoiceField(
        required=False,
        widget=forms.CheckboxSelectMultiple,
        choices=FAVORITE_COLORS_CHOICES,
    )
```

Féach na:ref: giuirléidí ionsuite 'le haghaidh tuilleadh faisnéise faoi na giuirléidí atá ar fáil agus cé na hargóintí a nglacann siad leo.

## Saincheapadh cásanna giuirléid

Nuair a dhéanann Django giuirléid mar HTML, ní dhéanann sé ach marcáil an-íosta - ní chuireann Django ainmneacha ranga leis, ná aon tréithe eile a bhaineann go sonrach le giuirléid. Ciallaíonn sé seo, mar shampla, go mbeidh giuirléidí uill:class: TextInput le feiceáil mar an gcéanna ar do leathanaigh ghréasáin.

\<styling-widget-classes\>Tá dhá bhealach ann chun giuirléidí a shaincheapadh: :ref: in aghaidh an tsampla giuirléid \<styling-widget-instances\>\`agus:ref: \`in aghaidh an aicme giuirléid.

### Camsanna giuirléid stíli

Más mian leat a chur ar shampla giuirléid amháin difriúil ó shampla eile, beidh ort tréithe breise a shonrú ag an am nuair a dhéantar an réad giuirléid a shannú agus a shannadh do réimse foirme (agus b'fhéidir roinnt rialacha a chur le do chomhaid CSS).

Mar shampla, glac an fhoirm seo a leanas:

```
from django import forms

class CommentForm(forms.Form):
    name = forms.CharField()
    url = forms.URLField()
    comment = forms.CharField()
```

This form will include [`TextInput`](#django.forms.TextInput) widgets for the name and comment
fields, and a [`URLInput`](#django.forms.URLInput) widget for the url field. Each has default
rendering - no CSS class, no extra attributes:

```pycon
>>> f = CommentForm(auto_id=False)
>>> print(f)
<div>Name:<input type="text" name="name" required></div>
<div>Url:<input type="url" name="url" required></div>
<div>Comment:<input type="text" name="comment" required></div>
```

On a real web page, you probably want to customize this. You might want a
larger input element for the comment, and you might want the 'name' widget to
have some special CSS class. It is also possible to specify the 'type'
attribute to use a different HTML5 input type. To do this, you use the
[`Widget.attrs`](#django.forms.Widget.attrs) argument when creating the widget:

```
class CommentForm(forms.Form):
    name = forms.CharField(widget=forms.TextInput(attrs={"class": "special"}))
    url = forms.URLField()
    comment = forms.CharField(widget=forms.TextInput(attrs={"size": "40"}))
```

Is féidir leat giuirléid a mhodhnú sa mhíniú foirm freisin:

```
class CommentForm(forms.Form):
    name = forms.CharField()
    url = forms.URLField()
    comment = forms.CharField()

    name.widget.attrs.update({"class": "special"})
    comment.widget.attrs.update(size="40")
```

Nó mura bhfuil an réimse dearbhaithe go díreach ar an bhfoirm (mar shampla réimsí foirme samhail), is féidir leat an tréith: attr: Form.fields a úsáid:

```
class CommentForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["name"].widget.attrs.update({"class": "special"})
        self.fields["comment"].widget.attrs.update(size="40")
```

Cuirfidh Django ansin san áireamh na tréithe breise san aschur rindreáilte:

```
>>> f = CommentForm(auto_id=False)
>>> print(f)
<div>Name:<input type="text" name="name" class="special" required></div>
<div>Url:<input type="url" name="url" required></div>
<div>Comment:<input type="text" name="comment" size="40" required></div>
```

Is féidir leat an HTML `id` a shocrú freisin ag baint úsáid:attr: ~Widget.Attrs. Féach:attr: BoundField.id\_for\_label mar shampla.

### Ranganna giuirléid stíl

Le giuirléidí, is féidir sócmhainní a chur leis (css\` agus javascript\`) agus a gcuma agus a n-iompar a shaincheapadh níos doimhne.

\<dynamic-property\>Go hachomair, beidh ort an giuirléid a fho-aicmiú agus fiú:ref: aicme istigh “Meáin” a shainiú \`nó: ref: \`maoin “meáin” \<assets-as-a-static-definition\>a chruthú.

Tá cláir Python beagán chun cinn i gceist leis na modhanna seo agus déantar cur síos mionsonraithe orthu sa threoir ábhair: doc: Foirm Assets \</topics/forms/media\>.

## Ranganna giuirléid bonn

\<built-in widgets\>Tá ranganna giuirléidí bonn:class: Widget agus:class: MultiWidget fo-aicmithe ag uile na:ref: giuirléidí ionsuite agus féadfaidh siad a bheith mar bhunús le haghaidh giuirléidí saincheaptha.

### `Giuirléid`

#### `class Widget(attrs=None)`

This abstract class cannot be rendered, but provides the basic attribute
[`attrs`](#django.forms.Widget.attrs). You may also implement or override the
[`render()`](#django.forms.Widget.render) method on custom widgets.

#### `attrs`

Foclóir ina bhfuil tréithe HTML le socrú ar an ngiuirléid rindreáilte.

```pycon
>>> from django import forms
>>> name = forms.TextInput(attrs={"size": 10, "title": "Your name"})
>>> name.render("name", "A name")
'<input title="Your name" type="text" name="name" value="A name" size="10">'
```

Má shannann tú luach `True` nó False\` do thréith, déanfar é mar thréith boolean HTML5:

```pycon
>>> name = forms.TextInput(attrs={"required": True})
>>> name.render("name", "A name")
'<input name="name" type="text" value="A name" required>'
>>>
>>> name = forms.TextInput(attrs={"required": False})
>>> name.render("name", "A name")
'<input name="name" type="text" value="A name">'
```

#### `supports_microseconds`

Tréith atá réamhshocraithe go `True`. Má tá sé socraithe go `False`, socraítear na luachanna micreasoicind de:class: ~datetime.datetime agus:class: ~datetime.time go 0\`.

#### `format_value(value)`

Glanann agus filleann sé luach le húsáid sa teimpléad giuirléid. Ní ráthaítear go mbeidh “luach” ionchur bailí, dá bhrí sin ba cheart forfheidhmithe fo-aicme a chlárú go cosanta.

#### `get_context(name, value, attrs)`

Filleann foclóir luachanna le húsáid agus an teimpléad giuirléid á rindreáil. De réir réamhshocraithe, tá eochair amháin sa fhoclóir, “'giuirléid”, ar léiriú foclóra é ar an ngiuirléid ina bhfuil na heochracha seo a leanas:

- ``` ``ainm ```: Ainm an réimse ón argóint ainm .
- `'is_hidden'`: Boolean a léiríonn an bhfuil an giuirléid seo i bhfolach nó nach bhfuil.
- `'riachtan`: Boolean a léiríonn cibé an bhfuil an réimse don ghuirléid seo ag teastáil nó nach bhfuil.
- `` `luach ``: An luach mar a thug ar ais ag: meth: format\_value.
- `'attrs'`: tréithe HTML atá le socrú ar an ngiuirléid rindreáilte. An teaglaim den tréith: attr: attrs agus an argóint `attrs`.
- `` `'template_name' ``: Luach `self.template_name`.

Is féidir le fo-aicmí `Widget` luachanna comhthéacs saincheaptha a sholáthar tríd an modh seo a shárú.

#### `id_for_label(id_)`

Tugann sé tréith ID HTML an ghuirléid seo ar ais le húsáid ag \<label\>\`\`\`, i bhfianaise ID an réimse. Tugann teaghrán folamh ar ais mura bhfuil aitheantas ar fáil.

Tá an crúca seo riachtanach toisc go bhfuil ileilimintí HTML ag roinnt giuirléidí agus, dá bhrí sin, iolracha Sa chás sin, ba cheart don modh seo luach aitheantais a fhreagraíonn don chéad aitheantas i gclibeanna an ghuirléid a thabhairt ar ais.

#### `render(name, value, attrs=None, renderer=None)`

Taispeánann sé giuirléid chuig HTML ag baint úsáide as an renderer a thugtar. Más é `` `renderer `` None\`, úsáidtear an rindeoir ón socrú:setting: FORM\_RENDER.

#### `value_from_datadict(data, files, name)`

Mar gheall ar fhoclóir sonraí agus ainm an ghuirléid seo, filleann sé luach an ghuirléid seo ar ais. \<django.http.HttpRequest.FILES\>D'fhéadfadh sonraí a thagann ó:attr: request.files \`a bheith i \`\`comhaid\`. Tugann sé ar ais `None` mura gcuirfí luach ar fáil. Tabhair faoi deara freisin gur féidir glaoch ar value\_from\_datadict\` níos mó ná uair amháin le linn láimhseáil sonraí foirme, mar sin má shaincheapann tú iad agus má chuireann tú próiseáil daor leis, ba cheart duit meicníocht caching éigin a chur i bhfeidhm tú féin.

#### `value_omitted_from_data(data, files, name)`

Mar gheall ar fhoclóirí sonra\` agus comhad agus ainm an ghuirléid seo, tugann sé ar ais cibé an bhfuil sonraí nó comhaid ann don ghuirléid nó nach bhfuil.

\<topics-modelform-save\>Bíonn tionchar ag toradh an mhodha cibé acu an dtagann réimse i bhfoirm mhúnla:ref: ar ais go dtí a réamhshocraithe nó nach bhfuil.

\<select multiple\>Is iad cásanna speisialta:class: ~django.forms.checkboxInput, :class: ~django.forms.checkboxSelectMultiple, agus:class: ~django.forms.selectMultiple, a fhilleann `False` i gcónaí toisc nach bhfuil bosca seiceála neamhsheiceáilte agus \`\` neamhroghnaithe le feiceáil i sonraí aighneacht HTML, mar sin níl sé anaithnid cibé an chuir an t-úsáideoir luach isteach nó nach bhfuil.

#### `use_fieldset`

Tréith chun a aithint an gcaithfear an giuirléid a ghrúpáil i \`\` le \<fieldset\>\`\`\`\` nuair a rindreáiltear \<legend\>é. Réamhshocraithe go `False` ach tá sé `True` nuair a bhíonn clibeanna iolracha \`\` sa ghuirléid amsúil:class: ~django.forms.CheckboxSelectMultiple, :class: ~django.forms.radioSelect, \<input\>:class: ~django.forms.datsplitMeWidget, agus:aicme: ~django.forms.selectDateWidget.

#### `use_required_attribute(initial)`

Mar gheall ar luach `tosaithe` réimse foirme, tugann tuairisceáin cibé acu is féidir an giuirléid a léiriú leis an tréith HTML `riachtan` nó nach féidir. \<django.forms.Form.use\_required\_attribute\>Úsáideann fo \<django.forms.Field.required\>irmeacha an modh seo in éineacht le: attr: Field.Required agus:attr: Form.USE\_REQUIRED\_ATTRIBUT chun a chinneadh an bhfuil an tréith `riachtan` a thaispeáint do gach réimse nó nach bhfuil.

De réir réamhshocraithe, filleann `False` le haghaidh giuirléidí i bhfolach agus `True` ar shlí eile. Is iad cásanna speisialta:class: ~django.forms.fileInput agus:class: ~django.forms.clearaableFileInput, a fhilleann `False` nuair a shocraítear `initial`, agus:class: ~django.forms.checkboxSelectMultiple a sheiceáil i gcónaí in ionad ceann amháin ar a laghad.

Override this method in custom widgets that aren't compatible with
browser validation. For example, a WYSIWYG text editor widget backed by
a hidden `textarea` element may want to always return `False` to
avoid browser validation on the hidden field.

### `Multiwidget`

#### `class MultiWidget(widgets, attrs=None)`

Giuirléid atá comhdhéanta de iliomad giuirléidí. :class: ~Django.Forms.MultiWidget oibríonn láimh ar láimh leis an: class: ~Django.Forms.MultivalueField.

[`MultiWidget`](#django.forms.MultiWidget) has one required argument:

#### `widgets`

Athraitheach ina bhfuil na giuirléidí is gá. Mar shampla:

```pycon
>>> from django.forms import MultiWidget, TextInput
>>> widget = MultiWidget(widgets=[TextInput, TextInput])
>>> widget.render("name", ["john", "paul"])
'<input type="text" name="name_0" value="john"><input type="text" name="name_1" value="paul">'
```

Féadfaidh tú foclóir a sholáthar chun iarmhairtí saincheaptha a shonrú don tréith ```ainm ``ar gach foghuirléid. Sa chás seo, do gach péire ``(eochair, giuirléid)```, cuirfear an eochair le ```ainm ``den ghuirléid d'fhonn an luach tréithe a ghiniúint. Féadfaidh tú an teaghrán folamh (```") a sholáthar d'eochair amháin, d'fhonn an iarmhír do ghuirléid amháin a chur faoi chois. Mar shampla:

```pycon
>>> widget = MultiWidget(widgets={"": TextInput, "last": TextInput})
>>> widget.render("name", ["john", "paul"])
'<input type="text" name="name" value="john"><input type="text" name="name_last" value="paul">'
```

Agus modh amháin riachtanach:

#### `decompress(value)`

Tógann an modh seo luach amháin “comhbhrúite” ón réimse agus filleann sé liosta de luachanna “díchomhbhrúite” ar ais. Is féidir glacadh leis an luach ionchuir bailí, ach ní gá go bhfuil sé folamh.

Caithfidh an fo-aicme an modh seo **a chur i bhfeidhme**, agus ós rud é go bhféadfadh an luach a bheith folamh, caithfidh an cur i bhfeidhm a bheith cosanta.

Is é an réasúnaíocht atá taobh thiar de “díchomhbhrúite” ná go bhfuil sé riachtanach luach comhcheangailte na réimse foirme a “roinnt” sna luachanna do gach giuirléid.

Sampla de seo is ea conas a chasann: class: SplitDateTimeWidget luach a: class: ~datetime.datetime ina liosta le dáta agus am roinnte ina dhá luach ar leithligh:

```
from django.forms import MultiWidget

class SplitDateTimeWidget(MultiWidget):
    # ...

    def decompress(self, value):
        if value:
            return [value.date(), value.time()]
        return [None, None]
```

> **Tip**
>
> Tabhair faoi deara go bhfuil modh comhlántach ag: :class: ~django.forms.multivaluefield: meth: ~django.forms.multivaluefield.compress leis an bhfreagracht mhalairt - luachanna glanta gach réimse ball a chomhcheangal i gceann amháin.

Soláthraíonn sé roinnt comhthéacs saincheaptha:

#### `get_context(name, value, attrs)`

Chomh maith leis an eochair `'widget'` a thuairiscítear in:meth: Widget.get\_context, cuireann `MultiWidget` eochair widget \['subwidgets'\] leis.

Is féidir iad seo a lúbadh sa teimpléad giuirléid:

```html+django
{% for subwidget in widget.subwidgets %}
    {% include subwidget.template_name with widget=subwidget %}
{% endfor %}
```

Seo giuirléid shampla a dhéanann fo-aicmi:class: MultiWidget chun dáta a thaispeáint leis an lá, an mhí agus an bhliain i mboscaí roghnaithe éagsúla. Tá sé beartaithe an giuirléid seo a úsáid le a:class: ~django.forms.datefield seachas a:class: ~django.forms.multivaluefield, mar sin tá: meth: ~Widget.value\_from\_dataDict curtha i bhfeidhm againn:

```
from datetime import date
from django import forms

class DateSelectorWidget(forms.MultiWidget):
    def __init__(self, attrs=None):
        days = {day: day for day in range(1, 32)}
        months = {month: month for month in range(1, 13)}
        years = {year: year for year in [2018, 2019, 2020]}
        widgets = [
            forms.Select(attrs=attrs, choices=days),
            forms.Select(attrs=attrs, choices=months),
            forms.Select(attrs=attrs, choices=years),
        ]
        super().__init__(widgets, attrs)

    def decompress(self, value):
        if isinstance(value, date):
            return [value.day, value.month, value.year]
        elif isinstance(value, str):
            year, month, day = value.split("-")
            return [day, month, year]
        return [None, None, None]

    def value_from_datadict(self, data, files, name):
        day, month, year = super().value_from_datadict(data, files, name)
        # DateField expects a single string that it can parse into a date.
        return "{}-{}-{}".format(year, month, day)
```

Cruthaíonn an tógálaí giuirléidí roinnt: class: Roghnaithe i liosta. Úsáideann an modh super () an liosta seo chun an giuirléid a chur ar bun.

Briseann an modh riachtanach: “~ MultiWidget.Decompress\` luach datetime.date \`\`isteach sna luachanna lae, míosa agus bliana a fhreagraíonn do gach giuirléid. Má roghnaíodh dáta neamhbhailí, mar shampla an 30 Feabhra nach raibh ann, téann an:class: \`~django.forms.datefield teaghrán ar an modh seo ina ionad sin, ionas gur gá parsáil air sin. Láimhseálann an `fillead` deiridh nuair is é `` `luach `` `None`, rud a chiallaíonn nach bhfuil aon réamhshocraithe againn dár bhfo-ghuirléidí.

Tugann cur i bhfeidhm réamhshocraithe de:meth: ~Widget.value\_from\_datadict liosta luachanna a fhreagraíonn do gach `Widget`. Tá sé seo oiriúnach nuair a úsáidtear `MultiWidget` le a:class: ~django.forms.MultivalueField. Ach ós rud é gur mhaith linn an giuirléid seo a úsáid le a:class: ~django.forms.datefield, a thógann luach amháin, tá an modh seo curtha againn. Comhcheanglaíonn an cur i bhfeidhm anseo na sonraí ó na fo-ghuirléidí i sreang san fhormáid a bhfuil súil ag: Class: ~Django.Forms.DateField ag súil leis.

## Giuirléidí ionsuite

\<selector-widgets\>\<file-upload-widgets\>\<composite-widgets\>Soláthraíonn Django léiriú ar na giuirléidí HTML bunúsacha go léir, móide roinnt grúpaí giuirléidí a úsáidtear go coitianta sa mhodúl django.forms.widgets\`, lena n-áirítear: ref: ionchur téacs \<text-widgets\>, :ref: láimhseáil ionchur illuacha'.

### Giuirléidí a láimhseáil ionchur

Baineann na giuirléidí seo úsáid as na heilimintí HTML `input` agus `textarea`.

#### `Textinput`

#### `class TextInput`

- `input_type`: `'téacs'`
- `template_name`: `django/foirmeach/giuirléid/text.html'`
- \<input type="text" ...\>Rinneálacha mar:

#### `Ionchur Uimhreach`

#### `class NumberInput`

- `input_type`: `'uimhreach'`
- `template_name`: `django/foirmeach/giuirléid/uimh.html'`
- \<input type="number" ...\>Rinneálacha mar:

Bí cúramach nach dtacaíonn gach brabhsálaí le huimhreacha áitiúla a iontráil i gcineálacha ionchuir ```uim Seachnaíonn Django féin iad a úsáid le haghaidh réimsí a bhfuil a maoin: attr: `~django.forms.field.localize` socraithe go ``True```.

#### `Ionchur ríomhphost`

#### `class EmailInput`

- `input_type`: `` `Ríomhphost `` \`
- `template_name`: `django/foirmeach/giuirléid/ríomhphost.html'`
- \<input type="email" ...\>Rinneálacha mar:

#### `Urlinput`

#### `class URLInput`

- `input_type`: URL \`
- `template_name`: `django/foirmeach/giuirléid/url.html'`
- \<input type="url" ...\>Rinneálacha mar:

#### `ColorInput`

> **New in Django 5.2**

#### `class ColorInput`

- `input_type`: `'color'`
- `template_name`:`'django/forms/widgets/color.html'`
- Renders as: `<input type="color" ...>`

#### `SearchInput`

> **New in Django 5.2**

#### `class SearchInput`

- `input_type`: `'search'`
- `template_name`: `'django/forms/widgets/search.html'`
- Renders as: `<input type="search" ...>`

#### `TelInput`

> **New in Django 5.2**

#### `class TelInput`

- `input_type`: `'tel'`
- `template_name`: `'django/forms/widgets/tel.html'`
- Renders as: `<input type="tel" ...>`

Browsers perform no client-side validation by default because telephone
number formats vary so much around the world. You can add some by setting
`pattern`, `minlength`, or `maxlength` in the [`Widget.attrs`](#django.forms.Widget.attrs)
argument.

Additionally, you can add server-side validation to your form field with a
validator like [`RegexValidator`](/ga/6.0/ref/validators/#django.core.validators.RegexValidator) or via
third-party packages, such as [django-phonenumber-field](https://pypi.org/project/django-phonenumber-field/).

#### `PasswordInput`

#### `class PasswordInput`

- `input_type`: pasfhocal \`
- `template_name`: `django/foirmeach/giuirléid/pasfho.html'`
- \<input type="password" ...\>Rinneálacha mar:

Tógann sé argóint roghnach amháin:

#### `render_value`

Cinneann sé an mbeidh luach líonta isteach sa ghuirléid nuair a aththaispeántar an fhoirm tar éis earráid bailíochtaithe (is é “False” réamhshocraithe).

#### Ionchur Hidden \`

#### `class HiddenInput`

- `input_type`: 'clúit' \`
- `template_name`: `django/foirme/widgets/hidden.html'`
- \<input type="hidden" ...\>Rinneálacha mar:

Tabhair faoi deara go bhfuil a: class: MultipleHiddenInput giuirléid ann freisin a chuimsíonn sraith eilimintí ionchuir i bhfolach.

#### `DateInput`

#### `class DateInput`

- `input_type`: `'téacs'`
- `template_name`: `django/foirmeach/giuirléid/date.html'`
- \<input type="text" ...\>Rinneálacha mar:

Glacann sé argóintí céanna as:class: TextInput, le argóint roghnach amháin eile:

#### `format`

An fhormáid ina taispeánfar luach tosaigh an réimse seo.

Mura gcuirtear argóint `formáid` ar fáil, is é an fhormáid réamhshocraithe an chéad fhormáid atá le fáil in:setting: DATE\_INPUT\_FORMATS agus respts:doc: /topics/i18n/formatting. Ní thacaíonn an giuirléid seo le formáidí `%U`, %W\`, agus `%j`.

> **Using the HTML5 "date" input type**
>
> If you are targeting browsers that support the
> [HTML5 "date" input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/date), you can override the `input_type`
> attribute to enable the browser’s native date picker:
>
> ```
> class MyDateInput(forms.DateInput):
>     input_type = "date"
>     format = "%Y-%m-%d"
> ```
>
> Alternatively:
>
> ```
> DateInput(attrs={"type": "date"}, format="%Y-%m-%d")
> ```
>
> HTML5 date inputs expect values in the ISO format `YYYY-MM-DD`. If a
> different format is provided, the field may appear empty even when a
> value exists. Setting the `format` attribute controls how Django
> provides the value, but the browser controls how it is displayed.
> Hence, the `format` attribute and the [`DATE_INPUT_FORMATS`](/ga/6.0/ref/settings/#std-setting-DATE_INPUT_FORMATS)
> setting will have no effect on the displayed value.

#### `DateTimeInput`

#### `class DateTimeInput`

- `input_type`: `'téacs'`
- `template_name`: `django/foirmeach/giuirléid/datetime.html'`
- \<input type="text" ...\>Rinneálacha mar:

Glacann sé argóintí céanna as:class: TextInput, le argóint roghnach amháin eile:

#### `format`

An fhormáid ina taispeánfar luach tosaigh an réimse seo.

Mura gcuirtear argóint `formáid` ar fáil, is é an fhormáid réamhshocraithe an chéad fhormáid a fhaightear in:setting: DATETIME\_INPUT\_FORMATS agus respts:doc: /topics/i18n/formatting. Ní thacaíonn an giuirléid seo le formáidí `%U`, %W\`, agus `%j`.

De réir réamhshocraithe, socraítear an chuid micrea-soicind den luach ama i gcónaí go `0`. Má tá micreasoicind ag teastáil, bain úsáid as fo-aicme leis an tréith: attr: ~Widget.supports\_microseconds atá socraithe go `True`.

#### Ionchur ama \`\`

#### `class TimeInput`

- `input_type`: `'téacs'`
- `template_name`: `django/foirmeach/giuirléid/time.html'`
- \<input type="text" ...\>Rinneálacha mar:

Glacann sé argóintí céanna as:class: TextInput, le argóint roghnach amháin eile:

#### `format`

An fhormáid ina taispeánfar luach tosaigh an réimse seo.

Mura gcuirtear argóint `formáid` ar fáil, is é an fhormáid réamhshocraithe an chéad fhormáid atá le fáil in:setting: TIME\_INPUT\_FORMATS agus respts:doc: /topics/i18n/formatting.

Chun micreasoicind a chóireáil, féach: aicme: DateTimeInput.

#### `Textarea`

#### `class Textarea`

- `template_name`: `django/foirmeach/giuirléid/textarea.html'`
- \<textarea\>Léiríonn sé mar: ...\</textarea\> \`\`

### Giuirléidí roghnóra agus bosca seiceála

\<input type="radio"\>Úsáideann na giuirléidí seo na heilimintí HTML `<select>`, `, agus<input type="checkbox">` \`\` .

Tá tréith `option_template_name` ag giuirléidí a dhéanann roghanna iolracha a shonraíonn an teimpléad a úsáidtear chun gach rogha a rinneadh. \<option\>\<select\>Mar shampla, don ghuirléid: Class: Select, tugann `select_option.html` an \`\` `le haghaidh` .

#### `Bosca Seiceála Ionchu`

#### `class CheckboxInput`

- `input_type`: `'bosca seiceála`
- `template_name`: `django/foirmeach/giuirléid/seicebox.html'`
- \<input type="checkbox" ...\>Rinneálacha mar:

Tógann sé argóint roghnach amháin:

#### `check_test`

Inghlaonta a thógann luach an `CheckboxInput` agus a thugann ar ais `True` má chóir an bosca seiceála a sheiceáil don luach sin.

#### `Roghnaithe`

#### `class Select`

- `template_name`: `django/foirmeach/giuirléid/roghnaithe.html'`
- `option_template_name`: `` `django/foirmeach/giuirléid/roghnaithe_roghnaithe.html' ``
- \<select\>Léiríonn sé mar: ...\</select\> \<option ...\> \`\`

#### `choices`

Tá an tréith seo roghnach nuair nach bhfuil tréith “roghanna” ag an réimse foirme. Má dhéanann sé, athróidh sé aon rud a shocraíonn tú anseo nuair a dhéantar an tréith a nuashonrú ar:class: Field.

#### `NullbooleanSelect`

#### `class NullBooleanSelect`

- `template_name`: `django/foirmeach/giuirléid/roghnaithe.html'`
- `option_template_name`: `` `django/foirmeach/giuirléid/roghnaithe_roghnaithe.html' ``

Roghnaigh giuirléid le roghanna 'Anaithnid', 'Tá' agus 'Níl'

#### `Roghnaigh Iolraithe`

#### `class SelectMultiple`

- `template_name`: `django/foirmeach/giuirléid/roghnaithe.html'`
- `option_template_name`: `` `django/foirmeach/giuirléid/roghnaithe_roghnaithe.html' ``

\<select multiple\>Cosúil le:aicme: Roghnaigh \`, ach ceadaíonn roghnú iolrach: \`...\</select\> \`\`

#### `RadioSelect`

#### `class RadioSelect`

- `template_name`: `django/foirmeach/giuirléid/radio.html'`
- `option_template_name`: `django/foirmeach/giuirléid/radio_option.html'`

\<div\>Cosúil le:class: Roghnaigh \`, ach rinneadh mar liosta de na cnaipí raidió laistigh de chlibeanna \`\`:

```html
<div>
  <div><input type="radio" name="..."></div>
  ...
</div>
```

Le haghaidh níos mó rialaithe gráinneach ar an marcáil a ghintear, is féidir leat lúb thar na cnaipí raidió sa teimpléad. Ag glacadh le foirm `myform` le réimse `beatles` a úsáideann `RadioSelect` mar a ghuirléid:

```html+django
<fieldset>
    <legend>{{ myform.beatles.label }}</legend>
    {% for radio in myform.beatles %}
    <div class="myradio">
        {{ radio }}
    </div>
    {% endfor %}
</fieldset>
```

Ghinfeadh sé seo an HTML seo a leanas:

```html
<fieldset>
    <legend>Radio buttons</legend>
    <div class="myradio">
        <label for="id_beatles_0"><input id="id_beatles_0" name="beatles" type="radio" value="john" required> John</label>
    </div>
    <div class="myradio">
        <label for="id_beatles_1"><input id="id_beatles_1" name="beatles" type="radio" value="paul" required> Paul</label>
    </div>
    <div class="myradio">
        <label for="id_beatles_2"><input id="id_beatles_2" name="beatles" type="radio" value="george" required> George</label>
    </div>
    <div class="myradio">
        <label for="id_beatles_3"><input id="id_beatles_3" name="beatles" type="radio" value="ringo" required> Ringo</label>
    </div>
</fieldset>
```

Áiríodh sin na clibeanna \<label\>\`\`\`. Chun níos gráinneach a fháil, is féidir leat tréithe `tag`, choice\_label\` agus `id_for_label` gach cnaipe raidió a úsáid. Mar shampla, an teimpléad seo...

```html+django
<fieldset>
    <legend>{{ myform.beatles.label }}</legend>
    {% for radio in myform.beatles %}
    <label for="{{ radio.id_for_label }}">
        {{ radio.choice_label }}
        <span class="radio">{{ radio.tag }}</span>
    </label>
    {% endfor %}
</fieldset>
```

... beidh an HTML seo a leanas mar thoradh air:

```html
<fieldset>
    <legend>Radio buttons</legend>
    <label for="id_beatles_0">
        John
        <span class="radio"><input id="id_beatles_0" name="beatles" type="radio" value="john" required></span>
    </label>
    <label for="id_beatles_1">
        Paul
        <span class="radio"><input id="id_beatles_1" name="beatles" type="radio" value="paul" required></span>
    </label>
    <label for="id_beatles_2">
        George
        <span class="radio"><input id="id_beatles_2" name="beatles" type="radio" value="george" required></span>
    </label>
    <label for="id_beatles_3">
        Ringo
        <span class="radio"><input id="id_beatles_3" name="beatles" type="radio" value="ringo" required></span>
    </label>
</fieldset>
```

\<div\>Má shocraíonn tú gan lúb thar na cnaipí raidió - m.sh., má chuimsíonn do theimpléad `{{myform.beatles}}` -- aschur iad i \`\` le clibeanna `<div>`, mar atá thuas.

Faigheann an co \<div\>imeádán seachtrach `` `tréith `id `` den ghuirléid, má tá sé sainmhínithe, nó:attr: BoundField.AUTO\_ID ar shlí eile.

Agus tú ag lúbadh thar na cnaipí raidió, cuimsíonn na clibeanna `lip` agus `ionchuir` tréithe `for` agus id\`, faoi seach. Tá tréith `id_for_label` ag gach cnaipe raidió chun aitheantas an eilimint a aschur.

#### `SeiceboxSelectMultiple`

#### `class CheckboxSelectMultiple`

- `template_name`: `django/foirmeach/giuirléid/checkbox_select.html'`
- `option_template_name`: `django/foirmeach/giuirléid/seicebox_option.html'`

Cosúil le:class: SelectMultiple, ach rinneadh mar liosta boscaí seiceála:

```html
<div>
  <div><input type="checkbox" name="..." ></div>
  ...
</div>
```

Faigheann an co \<div\>imeádán seachtrach `` `tréith `id `` den ghuirléid, má tá sé sainmhínithe, nó:attr: BoundField.AUTO\_ID ar shlí eile.

Cosúil le: Class: RadioSelect, is féidir leat lúb thar na boscaí seiceála aonair le haghaidh roghanna an ghuirléid. Gan amhlai:Class: RadioSelect, ní chuimsíonn na boscaí seiceála an tréith HTML `riachtan` má theastaíonn an réimse toisc go mbeadh bailíochtú brabhsálaí ag iarraidh gach bosca seiceála a sheiceáil in ionad ceann amháin ar a laghad.

Nuair a dhéantar na boscaí seiceála, cuimsíonn na clibeanna `lip` agus ```ionchur ``tréithe ``for``` agus `id`, faoi seach. Tá tréith `id_for_label` ag gach bosca seiceála chun aitheantas an eilimint a aschur.

### Giuirléidí uaslódáil

#### `FileInput`

#### `class FileInput`

- `template_name`: `django/foirme/giuirléid/comhad.html'`
- \<input type="file" ...\>Rinneálacha mar:

#### `ClearableFileInput`

#### `class ClearableFileInput`

- `template_name`: `django/foirmeach/giuirléid/clearable_file_input.html'`
- Léiríonn sé mar: `<input type="file" ...>` le hionchur bosca seiceála breise chun luach an réimse a ghlanadh, mura bhfuil an réimse ag teastáil agus mura bhfuil sonraí tosaigh aige.

### Giuirléidí ilchod

#### `Ionchur Ilchluitheach`

#### `class MultipleHiddenInput`

- `template_name`: `django/foirme/giuirléid/multiple_hidden.html'`
- \<input type="hidden" ...\>Rinsí mar: clibeanna iolracha

Giuirléid a láimhseálann go leor giuirléidí i bhfolach do réimsí a bhfuil liosta luachanna acu

#### `SplitDateTimeWidget`

#### `class SplitDateTimeWidget`

- `template_name`: `django/foirmeach/giuirléid/splitdatetime.html'`

Fillteán (ag baint úsáide:class: MultiWidget) timpeall dhá ghuirléid: :class: DateInput don dáta, agus:class: TimeInput don am. Ní mór é a úsáid le:class: SplitDateTimeField seachas: class: DateTimeField.

Tá roinnt argóintí roghnacha ag `SplitDateTimeWidget`:

#### `date_format`

Cosúil le:attr: DateInput.format

#### `time_format`

Cosúil le:attr: TimeInput.format

#### `date_attrs`

#### `time_attrs`

Cosúil le:attr: Widget.Attrs. Foclóir ina bhfuil tréithe HTML le socrú ar na giuirléidí rindered:class: DateInput agus:class: TimeInput faoi seach. Mura bhfuil na tréithe seo socraithe, úsáidtear: attr: Widget.attrs ina ionad.

#### `SplithiddendateTimeWidget`

#### `class SplitHiddenDateTimeWidget`

- `template_name`: `django/foirmeach/giuirléid/splithiddendatetime.html'`

Cosúil le:class: SplitDateTimeWidget, ach úsáideann sé: class: HiddenInput don dáta agus am araon.

#### `SelectDateWidget`

#### `class SelectDateWidget`

- `template_name`: `django/foirmeach/giuirléid/roghnaithe_dát.html'`

Fillteán timpeall trí: aicme: ~django.forms.select giuirléidí: ceann amháin ar feadh míosa, lá agus bliana.

Glacann sé roinnt argóintí roghnach

#### `years`

Liosta roghnach de na blianta le húsáid sa bhosca roghnaithe “bliain”. Is é an réamhshocrú liosta ina bhfuil an bhliain reatha agus na 9 mbliana amach romhainn.

#### `months`

Ordú roghnach míonna le húsáid sa bhosca roghnaithe “míonna”.

Freagraíonn eochracha an dict d'uimhir na míosa (1-innéacsaithe) agus is iad na luachanna na míonna a thaispeántar:

```
MONTHS = {
    1: _("jan"),
    2: _("feb"),
    3: _("mar"),
    4: _("apr"),
    5: _("may"),
    6: _("jun"),
    7: _("jul"),
    8: _("aug"),
    9: _("sep"),
    10: _("oct"),
    11: _("nov"),
    12: _("dec"),
}
```

#### `empty_label`

Mura bhfuil an: class: ~django.forms.DateField ag teastáil, beidh rogha folamh ag :class: SelectDateWidget ag barr an liosta (atá `---` de réir réamhshocraithe). Is féidir leat téacs an lipéid seo a athrú leis an tréith `empty_label`. Is féidir le `empty_label` a bheith ina `string`, liost\`, nó `tuple`. Nuair a úsáidtear sreang, beidh rogha folamh ag gach bosca roghnaithe leis an lipéad seo. Más ```liosta ``nó ``tuple``` de 3 eilimint sreangán é `empty_label`, beidh a lipéad saincheaptha féin ag na boscaí roghnaithe. Ba chóir go mbeadh na lipéid san ord seo `('year_label', 'month_label', 'day_label')`.

```python
# A custom empty label with string
field1 = forms.DateField(widget=SelectDateWidget(empty_label="Nothing"))

# A custom empty label with tuple
field1 = forms.DateField(
    widget=SelectDateWidget(
        empty_label=("Choose Year", "Choose Month", "Choose Day"),
    ),
)
```