---
title: "Foirmeacha a chruthú ó shamhl"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/topics/forms/modelforms/
canonical: https://djangodocs.dev/ga/6.1/topics/forms/modelforms/
---
# Foirmeacha a chruthú ó shamhl

## `Samhlfhoirme`

#### `class ModelForm`

Má tá aip faoi thiomáint bunachar sonraí á thógáil agat, is dócha go mbeidh foirmeacha agat a léarscálann go dlúth do mhúnlaí Django. Mar shampla, b'fhéidir go mbeadh samhail BlogComment agat, agus ba mhaith leat foirm a chruthú a ligeann do dhaoine tuairimí a chur isteach. Sa chás seo, bheadh sé iomarcach na cineálacha réimse i d'fhoirm a shainiú, toisc go bhfuil na réimsí i do mhúnla sainmhínithe agat cheana féin.

Ar an gcúis seo, soláthraíonn Django rang cúntóra a ligeann duit rang Form a chruthú ó mhúnla Django.

Mar shampla:

```pycon
>>> from django.forms import ModelForm
>>> from myapp.models import Article

# Create the form class.
>>> class ArticleForm(ModelForm):
...     class Meta:
...         model = Article
...         fields = ["pub_date", "headline", "content", "reporter"]
...

# Creating a form to add an article.
>>> form = ArticleForm()

# Creating a form to change an existing article.
>>> article = Article.objects.get(pk=1)
>>> form = ArticleForm(instance=article)
```

### Cineálacha réimse

Beidh réimse foirme ag an rang `Foirm` a ghintear do gach réimse samhail a shonraítear, san ord a shonraítear sa tréith réimsí réimsí \`réimsí \`réimsí \`.

Tá réimse foirme réamhshocraithe comhfhreagrach ag gach réimse samhail Mar shampla, léirítear `charfield` ar mhúnla mar charfield\` ar fhoirm. Léirítear samhail `` `ManyTomanyField `` mar `MultiplechoiceField`. Seo an liosta iomlán na tiontaithe:

| Réimse múnla | Réimse foirm |
| --- | --- |
| [`AutoField`](/ga/6.1/ref/models/fields/#django.db.models.AutoField) | Ní léirítear san fhoirm |
| [`BigAutoField`](/ga/6.1/ref/models/fields/#django.db.models.BigAutoField) | Ní léirítear san fhoirm |
| [`BigIntegerField`](/ga/6.1/ref/models/fields/#django.db.models.BigIntegerField) | [`IntegerField`](/ga/6.1/ref/forms/fields/#django.forms.IntegerField) with<br>`min_value` set to -9223372036854775808<br>and `max_value` set to 9223372036854775807. |
| [`BinaryField`](/ga/6.1/ref/models/fields/#django.db.models.BinaryField) | [`CharField`](/ga/6.1/ref/forms/fields/#django.forms.CharField), if<br>[`editable`](/ga/6.1/ref/models/fields/#django.db.models.Field.editable) is set to<br>`True` on the model field, otherwise not<br>represented in the form. |
| [`BooleanField`](/ga/6.1/ref/models/fields/#django.db.models.BooleanField) | [`BooleanField`](/ga/6.1/ref/forms/fields/#django.forms.BooleanField), or<br>[`NullBooleanField`](/ga/6.1/ref/forms/fields/#django.forms.NullBooleanField) if<br>`null=True`. |
| [`CharField`](/ga/6.1/ref/models/fields/#django.db.models.CharField) | [`CharField`](/ga/6.1/ref/forms/fields/#django.forms.CharField) with<br>`max_length` set to the model field's<br>`max_length` and<br>[`empty_value`](/ga/6.1/ref/forms/fields/#django.forms.CharField.empty_value)<br>set to `None` if `null=True`. |
| [`DateField`](/ga/6.1/ref/models/fields/#django.db.models.DateField) | [`DateField`](/ga/6.1/ref/forms/fields/#django.forms.DateField) |
| [`DateTimeField`](/ga/6.1/ref/models/fields/#django.db.models.DateTimeField) | [`DateTimeField`](/ga/6.1/ref/forms/fields/#django.forms.DateTimeField) |
| [`DecimalField`](/ga/6.1/ref/models/fields/#django.db.models.DecimalField) | [`DecimalField`](/ga/6.1/ref/forms/fields/#django.forms.DecimalField) |
| [`DurationField`](/ga/6.1/ref/models/fields/#django.db.models.DurationField) | [`DurationField`](/ga/6.1/ref/forms/fields/#django.forms.DurationField) |
| [`EmailField`](/ga/6.1/ref/models/fields/#django.db.models.EmailField) | [`EmailField`](/ga/6.1/ref/forms/fields/#django.forms.EmailField) |
| [`FileField`](/ga/6.1/ref/models/fields/#django.db.models.FileField) | [`FileField`](/ga/6.1/ref/forms/fields/#django.forms.FileField) |
| [`FilePathField`](/ga/6.1/ref/models/fields/#django.db.models.FilePathField) | [`FilePathField`](/ga/6.1/ref/forms/fields/#django.forms.FilePathField) |
| [`FloatField`](/ga/6.1/ref/models/fields/#django.db.models.FloatField) | [`FloatField`](/ga/6.1/ref/forms/fields/#django.forms.FloatField) |
| [`ForeignKey`](/ga/6.1/ref/models/fields/#django.db.models.ForeignKey) | [`ModelChoiceField`](/ga/6.1/ref/forms/fields/#django.forms.ModelChoiceField)<br>(see below) |
| [`ImageField`](/ga/6.1/ref/models/fields/#django.db.models.ImageField) | [`ImageField`](/ga/6.1/ref/forms/fields/#django.forms.ImageField) |
| [`IntegerField`](/ga/6.1/ref/models/fields/#django.db.models.IntegerField) | [`IntegerField`](/ga/6.1/ref/forms/fields/#django.forms.IntegerField) |
| `Ipaddressfield` | `Ipaddressfield` |
| [`GenericIPAddressField`](/ga/6.1/ref/models/fields/#django.db.models.GenericIPAddressField) | [`GenericIPAddressField`](/ga/6.1/ref/forms/fields/#django.forms.GenericIPAddressField) |
| [`JSONField`](/ga/6.1/ref/models/fields/#django.db.models.JSONField) | [`JSONField`](/ga/6.1/ref/forms/fields/#django.forms.JSONField) |
| [`ManyToManyField`](/ga/6.1/ref/models/fields/#django.db.models.ManyToManyField) | [`ModelMultipleChoiceField`](/ga/6.1/ref/forms/fields/#django.forms.ModelMultipleChoiceField)<br>(see below) |
| [`PositiveBigIntegerField`](/ga/6.1/ref/models/fields/#django.db.models.PositiveBigIntegerField) | [`IntegerField`](/ga/6.1/ref/forms/fields/#django.forms.IntegerField) |
| [`PositiveIntegerField`](/ga/6.1/ref/models/fields/#django.db.models.PositiveIntegerField) | [`IntegerField`](/ga/6.1/ref/forms/fields/#django.forms.IntegerField) |
| [`PositiveSmallIntegerField`](/ga/6.1/ref/models/fields/#django.db.models.PositiveSmallIntegerField) | [`IntegerField`](/ga/6.1/ref/forms/fields/#django.forms.IntegerField) |
| [`SlugField`](/ga/6.1/ref/models/fields/#django.db.models.SlugField) | [`SlugField`](/ga/6.1/ref/forms/fields/#django.forms.SlugField) |
| [`SmallAutoField`](/ga/6.1/ref/models/fields/#django.db.models.SmallAutoField) | Ní léirítear san fhoirm |
| [`SmallIntegerField`](/ga/6.1/ref/models/fields/#django.db.models.SmallIntegerField) | [`IntegerField`](/ga/6.1/ref/forms/fields/#django.forms.IntegerField) |
| [`TextField`](/ga/6.1/ref/models/fields/#django.db.models.TextField) | [`CharField`](/ga/6.1/ref/forms/fields/#django.forms.CharField) with<br>`widget=forms.Textarea` |
| [`TimeField`](/ga/6.1/ref/models/fields/#django.db.models.TimeField) | [`TimeField`](/ga/6.1/ref/forms/fields/#django.forms.TimeField) |
| [`URLField`](/ga/6.1/ref/models/fields/#django.db.models.URLField) | [`URLField`](/ga/6.1/ref/forms/fields/#django.forms.URLField) |
| [`UUIDField`](/ga/6.1/ref/models/fields/#django.db.models.UUIDField) | [`UUIDField`](/ga/6.1/ref/forms/fields/#django.forms.UUIDField) |

Mar a d'fhéadfá a bheith ag súil leis, is cásanna speisialta iad na cineálacha réimse samhail `ForeignKey` agus `ManyTomanyField`:

- Léirítear `ForeignKey` le `Django.Forms.ModelChoiceField`, ar ChoiceField\` is samhail `QuerySet` iad a roghanna.
- Léirítear `ManyTomanyField` le `Django.Forms.ModelMultipleChoiceField`, ar MultipleChoiceField\` is samhail `QuerySet` iad a roghanna.

Ina theannta sin, tá tréithe socraithe mar seo a leanas ag gach réimse foirme a ghintear

- Má tá `Blank=True` sa réimse samhail, ansin socraítear `riachtan` go `False` ar an réimse foirme. Seachas sin, `Required=True`.
- Socraítear `lip` réimse an fhoirme go `verbose_name` an réimse samhail, agus an chéad charachtar a chaipitliú.
- Socraítear `help_text` réimse an fhoirme go `help_text` sa réimse samhail.
- Má tá ```roghanna ``socraithe sa réimse samhail, ansin socraítear ``giuirléid``` réimse an fhoirme go ```Roghnaigh ``, agus roghanna a thagann ó `roghanna``` réimse an mhúnla. De ghnáth beidh an rogha bán a roghnaítear de réir réamhshocraithe san áireamh sna roghanna. Má tá an réimse ag teastáil, cuireann sé seo iallach ar an úsáideoir rogha a dhéanamh. Ní chuirfear an rogha bán san áireamh má tá ```blank=false ``sa réimse samhail agus luach sainráite ``default``` (roghnófar an luach `default` i dtosach ina ionad).

Faoi dheireadh, tabhair faoi deara gur féidir leat an réimse foirme a úsáidtear do réimse samhail ar leith a shárú. Féach Sárú ar na réimsí réamhshocraithe \_ thíos.

### Sampla iomlán

Smaoinigh ar an tacar samhlacha seo:

```
from django.db import models
from django.forms import ModelForm

TITLE_CHOICES = {
    "MR": "Mr.",
    "MRS": "Mrs.",
    "MS": "Ms.",
}

class Author(models.Model):
    name = models.CharField(max_length=100)
    title = models.CharField(max_length=3, choices=TITLE_CHOICES)
    birth_date = models.DateField(blank=True, null=True)

    def __str__(self):
        return self.name

class Book(models.Model):
    name = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)

class AuthorForm(ModelForm):
    class Meta:
        model = Author
        fields = ["name", "title", "birth_date"]

class BookForm(ModelForm):
    class Meta:
        model = Book
        fields = ["name", "authors"]
```

Leis na samhlacha seo, bheadh na fo-aicmí ModelForm thuas comhionann go garbh leis seo (is é an t-aon difríocht ná an modh save () , a phléifimid i nóiméad. ):

```
from django import forms

class AuthorForm(forms.Form):
    name = forms.CharField(max_length=100)
    title = forms.CharField(
        max_length=3,
        widget=forms.Select(choices=TITLE_CHOICES),
    )
    birth_date = forms.DateField(required=False)

class BookForm(forms.Form):
    name = forms.CharField(max_length=100)
    authors = forms.ModelMultipleChoiceField(queryset=Author.objects.all())
```

### Bailíochtú ar `Samhlfhoirme`

Tá dhá phríomhchéim i gceist le “Modelform” a bhailíochtú:

1. [Validating the form](/ga/6.1/ref/forms/validation/)
2. \<validating-objects\>:ref: An samhail samhail a bhailíochtú \`

Just like normal form validation, model form validation is triggered implicitly
when calling [`is_valid()`](/ga/6.1/ref/forms/api/#django.forms.Form.is_valid) or accessing the
[`errors`](/ga/6.1/ref/forms/api/#django.forms.Form.errors) attribute and explicitly when calling
`full_clean()`, although you will typically not use the latter method in
practice.

`Model` validation is triggered from within the form validation step right
after the form's `clean()` method is called. First, the model's
[`full_clean()`](/ga/6.1/ref/models/instances/#django.db.models.Model.full_clean) is called with
`validate_unique=False` and `validate_constraints=False`, then the model's
[`validate_unique()`](/ga/6.1/ref/models/instances/#django.db.models.Model.validate_unique) and
[`validate_constraints()`](/ga/6.1/ref/models/instances/#django.db.models.Model.validate_constraints) methods are called in
order.

> **Warning**
>
> Athraíonn an próiseas glantacháin an tsamhail samhail a chuirtear chuig an tógálaí ModelForm ar bhealaí éagsúla. Mar shampla, déantar aon réimsí dáta ar an tsamhail a thiontú ina rudaí dáta iarbhír. D'fhéadfadh bailíochtú a theip ar an samhail bhunúsach a fhágáil i stát neamhréireach agus dá bhrí sin ní mholtar é a athúsáid.

#### Sárú ar an modh clean () \`\`

Is féidir leat an modh clean () a shárú ar fhoirm mhúnla chun bailíochtú breise a sholáthar ar an mbealach céanna is féidir leat ar ghnáthfhoirm.

Beidh tréith `instance` i gcás foirme samhail atá ceangailte le réad samhail a thugann rochtain dá mhodhanna ar an samhail shonrach sin.

> **Warning**
>
> The `ModelForm.clean()` method sets flags that make the [model
> validation](/ga/6.1/ref/models/instances/#validating-objects) step validate the uniqueness of model
> fields that are marked as `unique`, `unique_together` or
> `unique_for_date|month|year`, as well as constraints.
>
> Más mian leat an modh ```clean () ``a shárú agus an bailíochtú seo a choinneáil, ní mór duit modh ``clean ()``` an rang tuismitheora a ghlaoch.

#### Idirghníomhaíocht le bailíochtú

Mar chuid den phróiseas bailíochtaithe, glaóidh ```ModelForm ``modh `glan ()``` gach réimse ar do mhúnla a bhfuil réimse comhfhreagrach aige ar d'fhoirm. Má tá aon réimsí samhlacha eisiata agat, ní reáchtálfar bailíochtú ar na réimsí sin. Féach an doiciméadach:doc: bailíochtú foirme' le haghaidh tuilleadh eolais fa\</ref/forms/validation\> oin gcaoi a n-oibríonn glanadh agus bailíochtú

The model's `clean()` method will be called before any uniqueness or
constraint checks are made. See [Validating objects](/ga/6.1/ref/models/instances/#validating-objects)
for more information on the model's `clean()` hook.

#### Breithnithe maidir le `error_messages` an tsamhail

Error messages defined at the form field level (
[`django.forms.Field.error_messages`](/ga/6.1/ref/forms/fields/#django.forms.Field.error_messages)) or at the
[form Meta](#modelforms-overriding-default-fields) level always take
precedence over the error messages defined at the model field level
([`django.db.models.Field.error_messages`](/ga/6.1/ref/models/fields/#django.db.models.Field.error_messages)).

Error messages defined on model fields
([`django.db.models.Field.error_messages`](/ga/6.1/ref/models/fields/#django.db.models.Field.error_messages)) are only used when the
`ValidationError` is raised during the [model validation](/ga/6.1/ref/models/instances/#validating-objects) step and no corresponding error messages are defined at
the form level.

Is féidir leat na teachtaireachtaí earráide ó NON\_FIELD\_ERRORS\` arna ardú trí bhailíochtú samhail a chur trí:data: ~django.core.exceptions.non\_field\_errors eochair leis an bhfoclóir error\_messages\` de rang Meta\` istigh `ModelForm`:

```
from django.core.exceptions import NON_FIELD_ERRORS
from django.forms import ModelForm

class ArticleForm(ModelForm):
    class Meta:
        error_messages = {
            NON_FIELD_ERRORS: {
                "unique_together": "%(model_name)s's %(field_labels)s are not unique.",
            }
        }
```

### An modh save () \`\`

Tá modh ```save () ``ag gach `ModelForm``` freisin. Cruthaíonn agus sábhálann an modh seo réad bunachar sonraí ó na sonraí atá ceangailte leis an bhfoirm. Is féidir le fo-aicme de ModelForm\` glacadh le samhail atá ann cheana mar an argóint eochairfhocal `instance`; má sholáthraítear é seo, déanfaidh save () an cás sin a nuashonrú. Mura soláthraítear é, cruthóidh save () sampla nua den tsamhail shonraithe:

```pycon
>>> from myapp.models import Article
>>> from myapp.forms import ArticleForm

# Create a form instance from POST data.
>>> f = ArticleForm(request.POST)

# Save a new Article object from the form's data.
>>> new_article = f.save()

# Create a form to edit an existing Article, but use
# POST data to populate the form.
>>> a = Article.objects.get(pk=1)
>>> f = ArticleForm(request.POST, instance=a)
>>> f.save()
```

Tabhair faoi deara mura bhfuil an fhoirm:ref: bailíochtaithe \`, déanfar glaoch ar \<validation-on-modelform\>save () ```amhlaidh trí ``form.errors``` a sheiceáil. Ardófar `Error lua` mura ndéanann na sonraí san fhoirm bailíochtú - ie, má mheasóidh `form.errors` go True\`.

Mura bhfuil réimse roghnach le feiceáil i sonraí na foirme, úsáideann an samhail mar thoradh air an réimse samhail: attr: ~django.db.models.field.default, má tá ceann ann, don réimse sin. \<select multiple\>Ní bhaineann an t-iompar seo le réimsí a úsáide:class: ~django.forms.checkboxInput, :class: ~django.forms.checkboxSelectMultiple, no:class: ~django.forms.selectMultiple (nó aon ghuirléid saincheaptha ciú:meth: ~django.forms.widget.value\_omitted\_fromdat\_dat\_dat\_Filleann modh \`\`False\` i gcónaí) ós rud é nach bhfuil bosca seiceála neamhsheiceáilte agus \`\` neamhroghnaithe le feiceáil i sonraí aighneachta foirme HTML. Úsáid réimse nó giuirléid fhoirme saincheaptha má tá API á dhearadh agat agus má theastaíonn uait an t-iompar titim réamhshocraithe do réimse a úsáideann ceann de na giuirléidí seo.

Glacann an modh ```save () ``seo le hargóint eochairfhocal roghnach ``commit```, a ghlacann le `True` nó `False`. Má ghlaonn tú ar ```save () ``le `Commit=false```, ansin cuirfidh sé rud ar ais nár shábháiltear go fóill chuig an mbunachar sonraí. Sa chás seo, is fútsa atá sé glaoch ar ```save () ``ar an gcás samhail mar thoradh air. <ref-models-force-insert>Tá sé seo úsáideach más mian leat próiseáil saincheaptha a dhéanamh ar an réad sula ndéanann tú é a shábháil, nó más mian leat ceann de na roghanna speisialaithe: ref: `samhail sábhála `a úsáid. Is é ``commit``` `True` de réir réamhshocraithe.

Feictear fo-éifeacht eile a bhaineann le Commit=false a úsáid nuair a bhíonn gaol go leor ag do mhúnla le samhail eile. Má tá gaol go leor ag do mhúnla agus má shonraíonn tú Commit=false nuair a shábhálann tú foirm, ní féidir le Django sonraí na foirme a shábháil láithreach don ghaol go leor. Tá sé seo toisc nach féidir sonraí go leor a shábháil mar shampla go dtí go mbeidh an cás sa bhunachar sonraí.

Chun oibriú timpeall ar an bhfadhb seo, gach uair a shábhálann tú foirm ag baint úsáide as Commit=false\`, cuireann Django modh ```save_m2m () ``le do fho-aicme ``ModelForm```. Tar éis duit an cás a tháirgeann an fhoirm a shábháil de láimh, is féidir leat save\_m2m () a ghairm chun na sonraí foirme go leor a shábháil. Mar shampla:

```pycon
# Create a form instance with POST data.
>>> f = AuthorForm(request.POST)

# Create, but don't save the new author instance.
>>> new_author = f.save(commit=False)

# Modify the author in some way.
>>> new_author.some_field = "some_value"

# Save the new instance.
>>> new_author.save()

# Now, save the many-to-many data for the form.
>>> f.save_m2m()
```

Calling `save_m2m()` is only required if you use `save(commit=False)`.
When you use a `save()` on a form, all data -- including many-to-many data --
is saved without the need for any additional method calls. For example:

```pycon
# Create a form instance with POST data.
>>> a = Author()
>>> f = AuthorForm(request.POST, instance=a)

# Create and save the new author instance. There's no need to do anything else.
>>> new_author = f.save()
```

Seachas na modhanna save () \`\`agus \`save\_m2m ()\`, oibríonn `Modelform` díreach ar an mbealach céanna le haon fhoirm `foirme` eile. Mar shampla, úsáidtear an modh ```is_valid () ``chun bailíocht a sheiceáil, úsáidtear an modh ``is_multipart ()``` chun a chinneadh an gá uaslódáil comhad ilpháirteach ó fhoirm (agus dá bhrí sin an gcaithfear `request.files` a chur chuig an bhfoirm), srl. Féach: binding-uploaded-files le haghaidh tuilleadh faisnéise.

### Roghnú na réimsí le húsáid

Moltar go láidir duit gach réimse a shocrú go sainráite ar chóir a chur in eagar sa fhoirm ag baint úsáide as an tréith `fields`. D'fhéadfadh fadhbanna slándála a bheith mar thoradh air go héasca nuair a cheadaíonn foirm gan choinne d'úsáideoir réimsí áirithe a shocrú, go háirithe nuair a chuirtear réimsí nua le samhail. Ag brath ar an gcaoi a ndéantar an fhoirm a léiriú, b'fhéidir nach mbeadh an fhadhb le feiceáil fiú ar an leathanach

The alternative approach would be to include all fields automatically, or
remove only some. This fundamental approach is known to be much less secure and
has led to serious exploits on major websites (e.g. [GitHub](https://github.blog/2012-03-04-public-key-security-vulnerability-and-mitigation/)
).

Tá dhá aicearra ar fáil, áfach, do chásanna inar féidir leat a ráthú nach mbaineann na hábhair imní slándála seo leat:

1. Socraigh an tréith `fields` don luach speisialta `` `__all__' `` chun a léiriú gur chóir gach réimse sa tsamhail a úsáid. Mar shampla:

   ```
   from django.forms import ModelForm

   class AuthorForm(ModelForm):
       class Meta:
           model = Author
           fields = "__all__"
   ```
2. Socraigh tréith `eisiam` d'aicme `Meta` istigh an ModelForm\` chuig liosta réimsí atá le eisiamh ón bhfoirm.

   Mar shampla:

   ```
   class PartialAuthorForm(ModelForm):
       class Meta:
           model = Author
           exclude = ["title"]
   ```

   Ós rud é go bhfuil na 3 réimse `ainm`, teideal \`\`agus \`\`dáta\_bhreith\` sa tsamhail `Údar`, beidh na réimsí `ainm` agus dáta\_bhreith\` i láthair ar an bhfoirm.

Má úsáidtear ceachtar díobh seo, is é an t-ord a bheidh na réimsí le feiceáil san fhoirm an t-ord a shainmhínítear na réimsí sa tsamhail, agus cásanna ManyTomanyField\` le feiceáil go deireanach.

Ina theannta sin, cuireann Django an riail seo a leanas i bhfeidhm: má shocraíonn tú `Editable=False` ar an réimse samhail, ní chuimseoidh an réimse sin *aon fhoirme* a cruthaíodh ón tsamhail trí ModelForm \`.

> **Note**
>
> Ní shocrófar aon réimsí nach bhfuil san áireamh i bhfoirm de réir an loighic thuas trí mhodh save () na foirme. Chomh maith leis sin, má chuireann tú na réimsí eisiata ar ais leis an bhfoirm de láimh, ní thionscnófar iad ón gcás samhail.
>
> Django will prevent any attempt to save an incomplete model, so if
> the model does not allow the missing fields to be empty, and does
> not provide a default value for the missing fields, any attempt to
> `save()` a `ModelForm` with missing fields will fail. To
> avoid this failure, you must instantiate your model with initial
> values for the missing, but required fields:
>
> ```
> author = Author(title="Mr")
> form = PartialAuthorForm(request.POST, instance=author)
> form.save()
> ```
>
> De rogha air sin, is féidir leat save (Commit=False) a úsáid agus aon réimsí breise riachtanacha a shocrú de láimh:
>
> ```
> form = PartialAuthorForm(request.POST)
> author = form.save(commit=False)
> author.title = "Mr"
> author.save()
> ```
>
> Féach an [alt ar fhoirmeacha sábhála](#the-save-method) le haghaidh tuilleadh sonraí maidir le save (Commit=False) a úsáid.

### Sárú ar na réimsí réamhshocraithe

Is réamhshocruithe ciallmhar iad na cineálacha réimse réamhshocraithe, mar a thuairiscítear sa tábla Cineálacha réimse \`\_ thuas. Má tá \`\`Datefield\` agat i do mhúnla, is dócha gur mhaith leat é sin a léiriú mar `Datefield` i do fhoirm. Ach tugann ModelForm an solúbthacht duit an réimse foirme a athrú do mhúnla ar leith.

Chun giuirléid saincheaptha do réimse a shonrú, bain úsáid as an tréith ```giuirléidí ``den aicme ``Meta``` istigh. Ba chóir go mbeadh sé seo ina fhoclóir a mhapáil ainmneacha réimse chuig ranganna nó cásanna

\<textarea\>\<input type="text"\>Mar shampla, más mian leat an `Charfield` don tréith ```ainm ``de ``Údar``` a léiriú le\`\` \`\` \`\` \`\` in ionad a réamhshocraithe \`\` , is féidir leat giuirléid an réimse a shárú:

```
from django.forms import ModelForm, Textarea
from myapp.models import Author

class AuthorForm(ModelForm):
    class Meta:
        model = Author
        fields = ["name", "title", "birth_date"]
        widgets = {
            "name": Textarea(attrs={"cols": 80, "rows": 20}),
        }
```

Glacann an foclóir ```giuirléidí ``le ceachtar cásanna giuirléid (m.sh., ``Textarea (...)```) nó ranganna (m.sh., `Textarea`). Tabhair faoi deara go ndéantar neamhaird ar an bhfoclóir giuirlisí do réimse samhail le tréith roghnaí\` neamh-folamh. Sa chás seo, ní mór duit an réimse foirme a shárú chun giuirléid dhifriúil a úsáid.

Ar an gcaoi chéanna, is féidir leat tréithe `labels`, help\_texts\` agus `error_messages` sa rang Meta\` istigh a shonrú más mian leat réimse a shaincheapadh tuilleadh.

Mar shampla más mian leat foclaíocht na teaghráin uile atá os comhair an úsáideora a shaincheapadh don réimse ainm :

```
from django.utils.translation import gettext_lazy as _

class AuthorForm(ModelForm):
    class Meta:
        model = Author
        fields = ["name", "title", "birth_date"]
        labels = {
            "name": _("Writer"),
        }
        help_texts = {
            "name": _("Some useful help text."),
        }
        error_messages = {
            "name": {
                "max_length": _("This writer's name is too long."),
            },
        }
```

Is féidir leat `field_classes` nó `formfield_callback` a shonrú freisin chun an cineál réimsí a shaincheapadh ag an bhfoirm.

Mar shampla, dá dteastaíonn uait MyslugFormField\` a úsáid don réimse `slug`, d'fhéadfá an méid seo a leanas a dhéanamh:

```
from django.forms import ModelForm
from myapp.models import Article

class ArticleForm(ModelForm):
    class Meta:
        model = Article
        fields = ["pub_date", "headline", "content", "reporter", "slug"]
        field_classes = {
            "slug": MySlugFormField,
        }
```

nó:

```
from django.forms import ModelForm
from myapp.models import Article

def formfield_for_dbfield(db_field, **kwargs):
    if db_field.name == "slug":
        return MySlugFormField()
    return db_field.formfield(**kwargs)

class ArticleForm(ModelForm):
    class Meta:
        model = Article
        fields = ["pub_date", "headline", "content", "reporter", "slug"]
        formfield_callback = formfield_for_dbfield
```

Faoi dheireadh, más mian leat smacht iomlán ar réimse - lena n-áirítear a chineál, bailíochtóirí, riachtanacha, srl. - is féidir leat é seo a dhéanamh trí réimsí a shonrú go dearbhaithe mar a dhéanfá i Foirm 'rialta.

Más mian leat bailíochtóirí réimse a shonrú, is féidir leat é sin a dhéanamh tríd an réimse a shainiú go dearbhaithe agus a pharaiméadar bailíodóirí a shocrú:

```
from django.forms import CharField, ModelForm
from myapp.models import Article

class ArticleForm(ModelForm):
    slug = CharField(validators=[validate_slug])

    class Meta:
        model = Article
        fields = ["pub_date", "headline", "content", "reporter", "slug"]
```

> **Note**
>
> Nuair a chuireann tú réimse foirme mar seo go sainráite, tá sé tábhachtach tuiscint a fháil ar an gcaoi a mbaineann `ModelForm` agus Foirm rialta .
>
> Is “Foirm” rialta é `ModelForm` atá in ann réimsí áirithe a ghiniúint go huathoibríoch. Braitheann na réimsí a ghintear go huathoibríoch ar ábhar an aicme Meta\` agus ar na réimsí a sainmhíníodh go dearbhaitheach cheana féin. Go bunúsach, ní ghinneoidh ModelForm réimsí nach bhfuil \*\* in easnamh\*\* ón bhfoirm, nó i bhfocail eile, réimsí nár sainmhíníodh go dearbhaitheach.
>
> Fágtar réimsí a shainmhínítear go dearbhaithe mar atá, dá bhrí sin déantar neamhaird ar aon saincheaptha a dhéantar ar thréithe `Meta` mar widgets\`, labels\`, help\_texts\`, nó error\_teachtaireachtaí ; ní bhaineann siad seo ach le réimsí a ghintear go huathoibríoch.
>
> Ar an gcaoi chéanna, ní tharraingíonn réimsí a shainmhínítear go dearbhaithe a gcuid tréithe mar ```max_length ``nó ``riachtan``` ón tsamhail chomhfhreagrach. Más mian leat an t-iompar a shonraítear sa tsamhail a choinneáil, ní mór duit na hargóintí ábhartha a shocrú go sainráite agus an réimse foirme á dhearbhú.
>
> Mar shampla, má tá cuma seo ar an tsamhail `Airteagal`:
>
> ```
> class Article(models.Model):
>     headline = models.CharField(
>         max_length=200,
>         null=True,
>         blank=True,
>         help_text="Use puns liberally",
>     )
>     content = models.TextField()
> ```
>
> agus ba mhaith leat roinnt bailíochtú saincheaptha a dhéanamh le haghaidh `ceannlíne`, agus na luachanna `blank` agus help\_text\` a choinneáil mar a shonraítear, b'fhéidir go mbeidh tú `ArticleForm` a shainiú mar seo:
>
> ```
> class ArticleForm(ModelForm):
>     headline = MyFormField(
>         max_length=200,
>         required=False,
>         help_text="Use puns liberally",
>     )
>
>     class Meta:
>         model = Article
>         fields = ["headline", "content"]
> ```
>
> Ní mór duit a chinntiú gur féidir cineál an réimse foirme a úsáid chun ábhar an réimse samhail comhfhreagrach a shocrú. Nuair nach bhfuil siad comhoiriúnach, gheobhaidh tú `Error luacha` toisc nach dtarlaíonn aon chomhshó intuigthe.
>
> Féach na:doc: foirm doiciméadú réimseach le haghaidh tuilleadh eolais faoi ré\</ref/forms/fields\> imsí agus a n-argóintí.

### Logánú réimsí a chumasú

De réir réamhshocraithe, ní dhéanfaidh na réimsí i ModelForm \`\`a gcuid sonraí a logánú. Chun logánú do réimsí a chumasú, is féidir leat an tréith \`\`localized\_fields\` a úsáid ar an rang `Meta`.

```
>>> from django.forms import ModelForm
>>> from myapp.models import Author
>>> class AuthorForm(ModelForm):
...     class Meta:
...         model = Author
...         localized_fields = ['birth_date']
```

Má shocraítear `localized_fields` go dtí an luach speisialta `'__all__'`, beidh gach réimse logánaithe.

### Foirm oidhreacht

As with basic forms, you can extend and reuse `ModelForm` classes by
inheriting them. This is useful if you need to declare extra fields or extra
methods on a parent class for use in a number of forms derived from models.
For example, using the previous `ArticleForm` class:

```pycon
>>> class EnhancedArticleForm(ArticleForm):
...     def clean_pub_date(self): ...
...
```

Cruthaíonn sé seo foirm a iompraíonn go cosúil le `ArticleForm`, ach amháin go bhfuil roinnt bailíochtaithe agus glantacháin bhreise ann don réimse `pub_date`.

Féadfaidh tú rang istigh `Meta` an tuismitheora a fho-aicmiú freisin más mian leat na liostaí `Meta.Fields` nó Meta.Exclude\` a athrú:

```pycon
>>> class RestrictedArticleForm(EnhancedArticleForm):
...     class Meta(ArticleForm.Meta):
...         exclude = ["body"]
...
```

Cuireann sé seo an modh breise leis an `EnhancedArticleForm` agus athraíonn sé an ArticleForm.meta\` bunaidh chun réimse amháin a bhaint.

Tá cúpla rud le tabhairt faoi deara, áfach.

- Tá feidhm ag gnáthrialacha um réiteach ainm Python. Má tá bunaicmí iolracha agat a dhearbhíonn rang istigh ```Meta`, ní úsáidfear ach an chéad cheann. Ciallaíonn sé seo ``Meta``` an linbh, má tá sé ann, ar shlí eile `Meta` an chéad thuismitheora, srl.
- Is féidir oidhreacht a dhéanamh ó ```Form ``agus `ModelForm``` araon ag an am céanna, áfach, ní mór duit a chinntiú go bhfuil ModelForm le feiceáil ar dtús sa MRO. Tá sé seo toisc go mbraitheann na ranganna seo ar mhithaiclasanna éagsúla agus ní féidir ach meiteachlas amháin a bheith ag rang.
- Is féidir `Field` a bhaint go dearbhaithe ó rang tuismitheoirí tríd an ainm a shocrú mar None ar an bhfo-aicme.

  Ní féidir leat an teicníc seo a úsáid ach chun diúltú as réimse a shainmhíníonn go dearbhaithe ag rang tuismitheoirí; ní chuirfidh sé cosc ar an meiteachlas `ModelForm` réimse réimse réamhshocraithe a ghiniúint. Chun diúltú ó réimsí réamhshocraithe, féach:ref: modelforms-selecting-fields.

### Luachanna tosaigh ar fáil

Mar is amhlaidh le foirmeacha rialta, is féidir sonraí tosaigh do fhoirmeacha a shonrú trí pharaiméadar `tosaithe` a shonrú agus an fhoirm á chur i bhfeidhm. Déanfaidh luachanna tosaigh a chuirtear ar fáil ar an mbealach seo athsháraíonn luachanna tosaigh ón réimse foirme agus luachanna ó shampla samhail Mar shampla:

```pycon
>>> article = Article.objects.get(pk=1)
>>> article.headline
'My headline'
>>> form = ArticleForm(initial={"headline": "Initial headline"}, instance=article)
>>> form["headline"].value()
'Initial headline'
```

### Feidhm monarcha ModelForm

Is féidir leat foirmeacha a chruthú ó mhúnla ar leith ag baint úsáide as an bhfeidhm neamhspleách: func: ~django.forms.models.modelform\_factory, in ionad sainmhíniú ranga a úsáid. D'fhéadfadh sé seo a bheith níos áisiúla mura bhfuil go leor saincheaptha agat le déanamh:

```pycon
>>> from django.forms import modelform_factory
>>> from myapp.models import Book
>>> BookForm = modelform_factory(Book, fields=["author", "title"])
```

Is féidir é seo a úsáid freisin chun modhnuithe a dhéanamh ar fhoirmeacha atá ann cheana, mar shampla trí na giuirléidí atá le húsáid le haghaidh réimse ar leith a shonrú:

```pycon
>>> from django.forms import Textarea
>>> Form = modelform_factory(Book, form=BookForm, widgets={"title": Textarea()})
```

Is féidir na réimsí atá le cur san áireamh a shonrú ag baint úsáide as na hargóintí eochairfhocal ```réimsí ``agus ``eisiam```, nó na tréithe comhfhreagracha ar an aicme `Meta` istigh `Modelform`. Féach an doiciméadú `ModelForm`:ref: modelforms-selecting-fields le do thoil.

... nó logánú a chumasú do réimsí ar leith:

```pycon
>>> Form = modelform_factory(Author, form=AuthorForm, localized_fields=["birth_date"])
```

## Foirmeacha múnla

#### `class models.BaseModelFormSet`

Cosúil le: doc: foirmeacha rialta, soláthraíonn D\</topics/forms/formsets\> jango cúpla rang foirm fheabhsaithe chun oibriú le samhlacha Django a dhéanamh níos áisiúla. Déanaimis an tsamhail Údar\` a athúsáid as thuas:

```pycon
>>> from django.forms import modelformset_factory
>>> from myapp.models import Author
>>> AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])
```

Ag baint úsáide as réimsí cuirtear srian ar an bhfoirmshraith chun na réimsí a thugtar a úsáid amháin. De rogha air sin, is féidir leat cur chuige “diúltú amach” a ghlacadh, ag sonrú cé na réimsí atá le eisiamh:

```pycon
>>> AuthorFormSet = modelformset_factory(Author, exclude=["birth_date"])
```

Cruthóidh sé seo tacar foirme atá in ann oibriú leis na sonraí a bhaineann leis an tsamhail Údar\`. Oibríonn sé díreach cosúil le foirmshraith rialta:

```pycon
>>> formset = AuthorFormSet()
>>> print(formset)
<input type="hidden" name="form-TOTAL_FORMS" value="1" id="id_form-TOTAL_FORMS"><input type="hidden" name="form-INITIAL_FORMS" value="0" id="id_form-INITIAL_FORMS"><input type="hidden" name="form-MIN_NUM_FORMS" value="0" id="id_form-MIN_NUM_FORMS"><input type="hidden" name="form-MAX_NUM_FORMS" value="1000" id="id_form-MAX_NUM_FORMS">
<div><label for="id_form-0-name">Name:</label><input id="id_form-0-name" type="text" name="form-0-name" maxlength="100"></div>
<div><label for="id_form-0-title">Title:</label><select name="form-0-title" id="id_form-0-title">
<option value="" selected>---------</option>
<option value="MR">Mr.</option>
<option value="MRS">Mrs.</option>
<option value="MS">Ms.</option>
</select><input type="hidden" name="form-0-id" id="id_form-0-id"></div>
```

> **Note**
>
> [`modelformset_factory()`](/ga/6.1/ref/forms/models/#django.forms.models.modelformset_factory) uses
> [`formset_factory()`](/ga/6.1/ref/forms/formsets/#django.forms.formsets.formset_factory) to generate formsets. This
> means that a model formset is an extension of a basic formset that knows
> how to interact with a particular model.

> **Note**
>
> Nuair a úsáidtear: ref: oidhreacht il-tábla \<multi-table-inheritance\>', beidh réimse nasc tuismitheora (de réir réamhshocraithe \`\`\<parent\_model\_name\>\_ptr\`) i bhfoirmeacha a ghintear ag monarcha foirmeacha a ghintear ag monarcha foirmeacha.

### An tacar ceisteanna a athrú

De réir réamhshocraithe, nuair a chruthaíonn tú tacar foirme ó mhúnla, úsáidfidh an tacar foirme tacar ceisteanna a chuimsíonn gach rud sa tsamhail (m.sh., Author.Objects.all () \`). Is féidir leat an t-iompar seo a shárú tríd an argóint `queryset` a úsáid:

```pycon
>>> formset = AuthorFormSet(queryset=Author.objects.filter(name__startswith="O"))
```

De rogha air sin, is féidir leat fo-aicme a chruthú a leagann `self.queryset` i `__init__`:

```
from django.forms import BaseModelFormSet
from myapp.models import Author

class BaseAuthorFormSet(BaseModelFormSet):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.queryset = Author.objects.filter(name__startswith="O")
```

Ansin, cuir do rang BaseAuthorFormSet chuig feidhm an mhonarcha:

```pycon
>>> AuthorFormSet = modelformset_factory(
...     Author, fields=["name", "title"], formset=BaseAuthorFormSet
... )
```

Más mian leat tacar foirme a thabhairt ar ais nach n-áirítear \* aon chás den tsamhail atá ann cheana féin, is féidir leat QuerySet folamh a shonrú:

```pycon
>>> AuthorFormSet(queryset=Author.objects.none())
```

### An fhoirm a athrú

De réir réamhshocraithe, nuair a úsáideann tú `modelformset_factory`, cruthófar foirm mhúnla ag baint úsáidea:func: ~django.forms.models.modelform\_factory. Go minic, is féidir go mbeadh sé úsáideach foirm mhúnla saincheaptha a shonrú. Mar shampla, is féidir leat foirm mhúnla saincheaptha a chruthú a bhfuil bailíochtú saincheaptha aige:

```
class AuthorForm(forms.ModelForm):
    class Meta:
        model = Author
        fields = ["name", "title"]

    def clean_name(self):
        # custom validation for the name field
        ...
```

Ansin, cuir d'fhoirm mhúnla chuig feidhm an mhonarcha:

```
AuthorFormSet = modelformset_factory(Author, form=AuthorForm)
```

Ní gá i gcónaí foirm mhúnla saincheaptha a shainiú. Tá roinnt argóintí ag an bhfeidhm modelformset\_factory\` a chuirtear tríd chuig modelform\_factory\`, a bhfuil cur síos orthu thíos.

### Giuirléidí a shonrú le húsáid sa fhoirm le `giuirléidí`

Ag baint úsáide as an paraiméadar ```giuirlisí ``, is féidir leat foclóir luachanna a shonrú chun rang giuirléid ``ModelForm``` a shaincheapadh do réimse áirithe. Oibríonn sé seo ar an mbealach céanna agus a oibríonn an foclóir ```giuirléid' ar an aicme ``Meta``` istigh de ModelForm \`:

```pycon
>>> AuthorFormSet = modelformset_factory(
...     Author,
...     fields=["name", "title"],
...     widgets={"name": Textarea(attrs={"cols": 80, "rows": 20})},
... )
```

### Logánú a chumasú do réimsí le `localized_fields`

Ag baint úsáide as an paraiméadar `localized_fields`, is féidir leat logánú a chumasú do réimsí san fhoirm.

```
>>> AuthorFormSet = modelformset_factory(
...     Author, fields=['name', 'title', 'birth_date'],
...     localized_fields=['birth_date'])
```

Má shocraítear `localized_fields` go dtí an luach speisialta `'__all__'`, beidh gach réimse logánaithe.

### Luachanna tosaigh ar fáil

Mar is amhlaidh le foirmeacha rialta, is féidir: ref: sonraí tosaigh a shonrú \<formsets-initial-data\>do fhoirmeacha sa tacar foirmeacha trí pharaiméadar \`\`initial\` a shonrú agus an aicme foirmeacha samhail a chuirtear ar ais ag: func: ~django.forms.models.modelformset\_factory. Mar sin féin, le foirmeacha samhlacha, ní bhaineann na luachanna tosaigh ach le foirmeacha breise, iad siúd nach bhfuil ceangailte le samhail shampla atá ann cheana. Má sháraíonn fad `tosaithe` líon na bhfoirmeacha breise, déantar neamhaird ar na sonraí tosaigh iomarcacha. Mura n-athraíonn an t-úsáideoir na foirmeacha breise le sonraí tosaigh, ní dhéanfar iad a bhailíochtú ná a shábháil.

### Rudaí a shábháil sa fhoirmshraith

Mar is amhlaidh le ModelForm\`, is féidir leat na sonraí a shábháil mar réad samhail. Déantar é seo le modh save () an tsraith foirmeacha:

```pycon
# Create a formset instance with POST data.
>>> formset = AuthorFormSet(request.POST)

# Assuming all is valid, save the data.
>>> instances = formset.save()
```

Tugann an modh save () ar ais na cásanna a shábháiltear chuig an mbunachar sonraí. Mura n-athraigh sonraí cás ar leith sna sonraí ceangailte, ní shábháilfear an cás sa bhunachar sonraí agus ní chuirfear san áireamh sa luach tuairisceáin (instancs', sa sampla thuas).

When fields are missing from the form (for example because they have been
excluded), these fields will not be set by the `save()` method. You can find
more information about this restriction, which also holds for regular
model forms, in [Selecting the fields to use](#selecting-the-fields-to-use).

Pas Commit=False\` chun na cásanna samhail neamhshábháilte a thabhairt ar ais:

```pycon
# don't save to the database
>>> instances = formset.save(commit=False)
>>> for instance in instances:
...     # do something with instance
...     instance.save()
...
```

Tugann sé seo an cumas duit sonraí a cheangal leis na cásanna sula ndéantar iad a shábháil leis an mbunachar sonraí. Má tá `ManyTomanyField` sa tacar foirme, beidh ort glaoch ar formset.save\_m2m () chun a chinntiú go sábhálfar na caidrimh go leor i gceart.

Tar éis glaoch ar save () ,, beidh trí thréith nua ag do shraith foirmeacha samhail ina bhfuil athruithe an fhoirmshraith:

#### `models.BaseModelFormSet.changed_objects`

#### `models.BaseModelFormSet.deleted_objects`

#### `models.BaseModelFormSet.new_objects`

### Líon na rudaí in-eagarthóireachta a theorannú

Mar is amhlaidh le foirmeacha rialta, is féidir leat na paraiméadair `max_num` agus `extra` a úsáid to:func: ~django.forms.models.modelformset\_factory chun líon na bhfoirmeacha breise a thaispeántar a theorannú.

Ní chuireann `max_num` cosc ar rudaí atá ann cheana a thaispeáint:

```pycon
>>> Author.objects.order_by("name")
<QuerySet [<Author: Charles Baudelaire>, <Author: Paul Verlaine>, <Author: Walt Whitman>]>

>>> AuthorFormSet = modelformset_factory(Author, fields=["name"], max_num=1)
>>> formset = AuthorFormSet(queryset=Author.objects.order_by("name"))
>>> [x.name for x in formset.get_queryset()]
['Charles Baudelaire', 'Paul Verlaine', 'Walt Whitman']
```

\<understanding-the-managementform\>Chomh maith leis sin, ní choisceann `extra=0` cásanna samhail nua a chruthú mar is féidir leat: ref: foirmeacha breise a chur le JavaScript \`nó seol sonraí POST breise. Féach: ref: \`model-formsets-edit-only maidir le conas é seo a dhéanamh.

Má tá luach `max_num` níos mó ná líon na rudaí gaolmhara atá ann cheana, cuirfear foirmeacha bán breise suas le `extra` leis an tacar foirmeacha, fad nach mbeidh líon iomlán na bhfoirmeacha níos mó ná `max_num`:

```pycon
>>> AuthorFormSet = modelformset_factory(Author, fields=["name"], max_num=4, extra=2)
>>> formset = AuthorFormSet(queryset=Author.objects.order_by("name"))
>>> for form in formset:
...     print(form)
...
<div><label for="id_form-0-name">Name:</label><input id="id_form-0-name" type="text" name="form-0-name" value="Charles Baudelaire" maxlength="100"><input type="hidden" name="form-0-id" value="1" id="id_form-0-id"></div>
<div><label for="id_form-1-name">Name:</label><input id="id_form-1-name" type="text" name="form-1-name" value="Paul Verlaine" maxlength="100"><input type="hidden" name="form-1-id" value="3" id="id_form-1-id"></div>
<div><label for="id_form-2-name">Name:</label><input id="id_form-2-name" type="text" name="form-2-name" value="Walt Whitman" maxlength="100"><input type="hidden" name="form-2-id" value="2" id="id_form-2-id"></div>
<div><label for="id_form-3-name">Name:</label><input id="id_form-3-name" type="text" name="form-3-name" maxlength="100"><input type="hidden" name="form-3-id" id="id_form-3-id"></div>
```

Cuireann luach `max_num` de `None` (an réamhshocrú) teorainn ard ar líon na bhfoirmeacha a thaispeántar (1000). Go praiticiúil tá sé seo coibhéiseach le haon teorainn.

### Cruthú rudaí nua a chosc

Ag baint úsáide as an paraiméadar edit\_only, is féidir leat cosc a chur ar chruthú aon rudaí nua:

```pycon
>>> AuthorFormSet = modelformset_factory(
...     Author,
...     fields=["name", "title"],
...     edit_only=True,
... )
```

Anseo, ní dhéanfaidh an tacar foirme ach cásanna Údar\` atá ann cheana a chur in eagar. Ní chruthófar nó a chur in eagar aon rudaí eile.

### Ag baint úsáide as foirmshraith samhail i radharc

Tá foirmeacha samhlacha an-chosúil le foirmeacha. Ligean le rá gur mhaith linn tacar foirme a chur i láthair chun cásanna samhail Údar\` a chur in eagar:

```
from django.forms import modelformset_factory
from django.shortcuts import render
from myapp.models import Author

def manage_authors(request):
    AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])
    if request.method == "POST":
        formset = AuthorFormSet(request.POST, request.FILES)
        if formset.is_valid():
            formset.save()
            # do something.
    else:
        formset = AuthorFormSet()
    return render(request, "manage_authors.html", {"formset": formset})
```

Mar a fheiceann tú, níl loighic radharc tacar foirmeacha samhail difriúil go mór ná loighic thacar foirmeacha “gnáth”. Is é an t-aon difríocht ná go nglaoimid ar formset.save () chun na sonraí a shábháil sa bhunachar sonraí. (Rinneadh cur síos air seo thuas, in:ref: saving-objects-in-the-formset.)

### Sárú ar ```clean () ``ar `ModelFormSet```

Just like with a `ModelForm`, by default the `clean()` method of a
`ModelFormSet` will validate that none of the items in the formset violate
the unique constraints on your model (either `unique`, `unique_together` or
`unique_for_date|month|year`). If you want to override the `clean()` method
on a `ModelFormSet` and maintain this validation, you must call the parent
class's `clean` method:

```
from django.forms import BaseModelFormSet

class MyModelFormSet(BaseModelFormSet):
    def clean(self):
        super().clean()
        # example custom validation across forms in the formset
        for form in self.forms:
            # your custom formset validation
            ...
```

Tabhair faoi deara freisin faoin am a shroicheann tú an chéim seo, go bhfuil cásanna samhail aonair cruthaithe cheana féin do gach ```Foirm ``. Ní leor luach a mhodhnú i `form.cleaned_data ``chun dul i bhfeidhm ar an luach sábháltha. Más mian leat luach a mhodhnú in `ModelFormSet.clean () ``ní mór duit ``form.instance``` a mhodhnú:

```
from django.forms import BaseModelFormSet

class MyModelFormSet(BaseModelFormSet):
    def clean(self):
        super().clean()

        for form in self.forms:
            name = form.cleaned_data["name"].upper()
            form.cleaned_data["name"] = name
            # update the instance value.
            form.instance.name = name
```

### Ag baint úsáide as tacar ceisteanna saincheaptha

Mar a dúradh níos luaithe, is féidir leat an tacar ceisteanna réamhshocraithe a úsáideann an tacar foirmeacha samhail a shárú:

```
from django.forms import modelformset_factory
from django.shortcuts import render
from myapp.models import Author

def manage_authors(request):
    AuthorFormSet = modelformset_factory(Author, fields=["name", "title"])
    queryset = Author.objects.filter(name__startswith="O")
    if request.method == "POST":
        formset = AuthorFormSet(
            request.POST,
            request.FILES,
            queryset=queryset,
        )
        if formset.is_valid():
            formset.save()
            # Do something.
    else:
        formset = AuthorFormSet(queryset=queryset)
    return render(request, "manage_authors.html", {"formset": formset})
```

Tabhair faoi deara go rachaimid an argóint `queryset` sna cásanna ```POST ``agus `GET``` sa sampla seo.

### Ag baint úsáide as an bhfoirm sa teimpléad

Tá trí bhealach ann chun tacar foirme a rinneadh i dteimpléad Django.

Ar dtús, is féidir leat ligean don fhoirmset an chuid is mó den obair a dhéanamh:

```html+django
<form method="post">
    {{ formset }}
</form>
```

Ar an dara dul síos, is féidir leat an tacar foirme a rinneadh de láimh, ach lig don fhoirm déileáil leis féin:

```html+django
<form method="post">
    {{ formset.management_form }}
    {% for form in formset %}
        {{ form }}
    {% endfor %}
</form>
```

Nuair a dhéanann tú na foirmeacha a rinneadh de láimh tú féin, bí cinnte an fhoirm bhainistíochta a thabhairt mar a thaispeán \<understanding-the-managementform\>Féach an:ref: doiciméadú foirm bhainistíochta .

Sa tríú háit, is féidir leat gach réimse a rinneadh de láimh

```html+django
<form method="post">
    {{ formset.management_form }}
    {% for form in formset %}
        {% for field in form %}
            {{ field.label_tag }} {{ field }}
        {% endfor %}
    {% endfor %}
</form>
```

Má roghnaíonn tú an tríú modh seo a úsáid agus mura ndéanann tú athrá thar na réimsí le lúb `{% for%}`, beidh ort an príomhréimse eochair a rinneadh. Mar shampla, má bhí réimsí ```ainm ``agus ``aois``` á ndéanamh agat de mhúnla:

```html+django
<form method="post">
    {{ formset.management_form }}
    {% for form in formset %}
        {{ form.id }}
        <ul>
            <li>{{ form.name }}</li>
            <li>{{ form.age }}</li>
        </ul>
    {% endfor %}
</form>
```

Tabhair faoi deara conas is gá dúinn `{{form.id}}` a rinneadh go sainráite. Cinntíonn sé seo go n-oibreoidh an tacar foirme samhail, sa chás POST \`, i gceart. (Glacann an sampla seo le príomh-eochair darb ainm id\`. Má tá d'eochair phríomhúil féin sainmhínithe go sainráite agat nach dtugtar id, déan cinnte go ndéantar é a léiriú.)

## Foirmeacha inlíne

#### `class models.BaseInlineFormSet`

Is ciseal beag tearbhaithe é foirmeacha inlíne ar bharr foirmeacha samhlacha. Déanann siad seo an cás oibriú le rudaí gaolmhara trí eochair eachtrach a shimpliú. Cuir i gcás go bhfuil an dá mhúnla seo agat:

```
from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    title = models.CharField(max_length=100)
```

Más mian leat tacar foirme a chruthú a ligeann duit leabhair a bhaineann le húdar áirithe a chur in eagar, d'fhéadfá seo a dhéanamh:

```pycon
>>> from django.forms import inlineformset_factory
>>> BookFormSet = inlineformset_factory(Author, Book, fields=["title"])
>>> author = Author.objects.get(name="Mike Royko")
>>> formset = BookFormSet(instance=author)
```

\<formset-prefix\>\<model name\>\`\`BookformSet\`\`\`'s:ref: réimír \`is é \`\`\`book\_set'\` (`_set`). Má tá a: attr: ~Django.db.Models.ForeignKey.Related\_Name de `Book` go Author \`,\`\` Book\`\`, úsáidtear é sin ina ionad.

> **Note**
>
> [`inlineformset_factory()`](/ga/6.1/ref/forms/models/#django.forms.models.inlineformset_factory) uses
> [`modelformset_factory()`](/ga/6.1/ref/forms/models/#django.forms.models.modelformset_factory) and marks
> `can_delete=True`.

> **See also**
>
> \<manually-rendered-can-delete-and-can-order\>:ref: Can\_delete agus can\_order a rindreáiltear de láimh .

### Modhanna forchoitianta ar `inlineFormSet`

Agus modhanna a shárú ar InlineFormSet\`, ba cheart duit fo-aicme: ~Models.BaseLineFormSet seachas: ~Models.BaseModelFormSet seachas: ~Models.BaseModelFormSet.

Mar shampla, más mian leat clean () a shárú:

```
from django.forms import BaseInlineFormSet

class CustomInlineFormSet(BaseInlineFormSet):
    def clean(self):
        super().clean()
        # example custom validation across forms in the formset
        for form in self.forms:
            # your custom formset validation
            ...
```

Féach freis:ref: model-formsets-overriding-clean.

Ansin nuair a chruthaíonn tú do shraith foirme inlíne, pas isteach san argóint roghnach `formset`:

```pycon
>>> from django.forms import inlineformset_factory
>>> BookFormSet = inlineformset_factory(
...     Author, Book, fields=["title"], formset=CustomInlineFormSet
... )
>>> author = Author.objects.get(name="Mike Royko")
>>> formset = BookFormSet(instance=author)
```

### Níos mó ná eochair eachtrach amháin don tsamhail chéanna

Má tá níos mó ná eochair eachtrach amháin don tsamhail chéanna i do mhúnla, beidh ort an débhríocht a réiteach de láimh ag baint úsáide as fk\_name\`. Mar shampla, smaoinigh ar an tsamhail seo a leanas:

```
class Friendship(models.Model):
    from_friend = models.ForeignKey(
        Friend,
        on_delete=models.CASCADE,
        related_name="from_friends",
    )
    to_friend = models.ForeignKey(
        Friend,
        on_delete=models.CASCADE,
        related_name="friends",
    )
    length_in_months = models.IntegerField()
```

Chun é seo a réiteach, is féidir leat `fk_name` a úsáid to:func: ~django.forms.models.inlineformset\_factory:

```pycon
>>> FriendshipFormSet = inlineformset_factory(
...     Friend, Friendship, fk_name="from_friend", fields=["to_friend", "length_in_months"]
... )
```

### Ag baint úsáide as tacar foirmeacha inlíne i radharc

B'fhéidir gur mhaith leat radharc a sholáthar a ligeann d'úsáideoir rudaí gaolmhara samhail a chur in eagar. Seo mar is féidir leat é sin a dhéanamh:

```
def manage_books(request, author_id):
    author = Author.objects.get(pk=author_id)
    BookInlineFormSet = inlineformset_factory(Author, Book, fields=["title"])
    if request.method == "POST":
        formset = BookInlineFormSet(request.POST, request.FILES, instance=author)
        if formset.is_valid():
            formset.save()
            # Do something. Should generally end with a redirect. For example:
            return HttpResponseRedirect(author.get_absolute_url())
    else:
        formset = BookInlineFormSet(instance=author)
    return render(request, "manage_books.html", {"formset": formset})
```

Tabhair faoi deara conas a théann muid `instance` sna cásanna ```POST ``agus `GET``` araon.

### Giuirléidí a shonrú le húsáid san fhoirm inlíne

Úsáideann `` `inlineformset_factory `` `modelformset_factory` agus cuireann an chuid is mó dá argóintí chuig modelformset\_factory\`. Ciallaíonn sé seo gur féidir leat an paraiméadar `widgets` a úsáid ar an mbealach céanna agus é a chur chuig modelformset\_factory\`. Féach Giuirléidí a shonrú le húsáid san fhoirm le giuirléidí \_ thuas.