--- title: "Bailíochtú foirm agus réimse" version: 5.2 locale: ga source: https://docs.djangoproject.com/ga/5.2/ref/forms/validation/ canonical: https://djangodocs.dev/ga/5.2/ref/forms/validation/ --- # Bailíochtú foirm agus réimse Tarlaíonn bailíochtú foirme nuair a ghlantar na sonraí. Más mian leat an próiseas seo a shaincheapadh, tá áiteanna éagsúla ann chun athruithe a dhéanamh, agus gach ceann acu ag freastal ar chuspóir difriúil. Reáchtáiltear trí chineál modhanna glantacháin le linn próiseála foirme. De ghnáth déantar iad seo a fhorghníomhú nuair a ghlaonn tú ar an modh ```is_valid () ``ar fhoirm. Tá rudaí eile ann a d'fhéadfadh glanadh agus bailíochtú a spreagadh freisin (rochtain a fháil ar an tréith ``earráidí ``nó glaoch ar `full_clean ()``` go díreach), ach de ghnáth ní bheidh siad ag teastáil. Go ginearálta, is féidir le haon mhodh glantacháin ```ValidationError` a ardú má tá fadhb ann leis na sonraí atá á phróiseáil aige, ag cur an fhaisnéis ábhartha chuig an tógálaí ``ValidationError`. :ref: `Féach thíos `le haghaidh an dea-chleachtas maidir le ``ValidationError``` a ardú. Mura n-ardaítear aon `ValidationError`, ba cheart don modh na sonraí glanta (normalaithe) a thabhairt ar ais mar réad Python. Is féidir an chuid is mó de bhailíochtú a dhéanamh ag baint úsáide as bailíodóirí \`\_ - cúntóirí is féidir a athúsáid. Is feidhmeanna (nó glaonna) iad bailíochtóirí a thógann argóint amháin agus a ardaíonn \`\`ValidationError\` ar ionchur neamhbhailí. Déantar bailíochtóirí a reáchtáil tar éis modhanna `to_python` agus `validate` an réimse a ghlaoch. Roinntear bailíochtú foirme ina roinnt céimeanna, ar féidir iad a shaincheapadh nó a shárú: - Is é an modh ```to_python () ``ar `Réimse``` an chéad chéim i ngach bailíochtú. Cuireann sé an luach ar chineál sonraí ceart agus ardaíonn sé `ValidationError` mura féidir é sin a dhéanamh. Glacann an modh seo leis an luach amh ón ngiuirléid agus filleann sé an luach tiontaithe ar ais. Mar shampla, iompróidh `Floatfield` na sonraí ina float\` Python nó ardóidh `ValidationError`. - Láimhseálann an modh ```validate () ``ar `Réimse``` bailíochtú réamh-shonrach nach bhfuil oiriúnach do bhailíochtóir. Tógann sé luach a cuireadh iallach ar chineál sonraí ceart agus ardaíonn sé `ValidationError` ar aon earráid. Ní thugann an modh seo aon rud ar ais agus níor cheart dó an luach a athrú. Ba chóir duit é a shárú chun loighic bhailíochtaithe nach féidir leat nó nach dteastaíonn uait bailíochtóir a chur isteach. - Ritheann an modh ```run_validators () ``ar `Réimse``` bailíochtóirí uile an réimse agus comhiomlánann sé na hearráidí go léir ina `ValidationError` amháin. Níor chóir go gcaithfidh tú an modh seo a shárú. - Tá an modh ```clean () ``ar fho-aicme ``Field``` freagrach as `to_python ()`, validate () \`, agus `run_validators ()` a reáchtáil san ord ceart agus a n-earráidí a iomadú. Má ardaíonn aon cheann de na modhanna, ag am ar bith, ValidationError, stopann an bailíochtú agus ardaítear an earráid sin. Tugann an modh seo na sonraí glan ar ais, a chuirtear isteach ansin isteach i bhfoclóir `cleaned_data` na foirme. - \Glaítear ar an modh ``` clean_ () `ar fho-aicme foirme -- ina gcuirtear ainm tréith réim se na foirme in ionad `` ```. Déanann an modh seo aon ghlanadh atá sonrach don tréith áirithe sin, nach mbaineann leis an gcineál réimse atá ann. Ní chuirtear an modh seo ar bith paraiméadair. Beidh ort luach an réimse a fheiceáil suas i self.cleaned\_data \`\`agus cuimhnigh gur réad Python é ag an bpointe seo, ní an teaghrán bunaidh a chuirtear isteach san fhoirm (beidh sé i \`\`cleaned\_data\` toisc gur ghlanadh an modh réimse ginearálta clean () thuas, na sonraí cheana féin). Mar shampla, dá dteastaíonn uait a bhailíochtú go raibh ábhar `charfield` ar a dtugtar `serialnumber` uathúil, bheadh clean\_serialnumber () \`\`an áit cheart chun é seo a dhéanamh. Ní theastaíonn réimse ar leith uait (is \`Charfield é), ach teastaíonn píosa bailíochtaithe atá sonrach le réimse foirme uait agus, b'fhéidir, na sonraí a ghlananach/normalú. Cuireann luach tuairisceáin an mhodha seo in ionad an luach atá ann cheana i cleaned\_data \`, mar sin caithfidh sé a bheith luach an réimse ó cleaned\_data\` (fiú mura n-athraigh an modh seo é) nó luach nua glantaithe. - Is féidir le modh ```clean () ``an fho-aicme foirme bailíochtú a dhéanamh a éilíonn rochtain ar réimsí iolracha foirme. Seo an áit a bhféadfá seiceálacha a chur isteach mar “má sholáthraítear réimse ``A```, caithfidh seoladh ríomhphoist bailí a bheith i réimse `B`”. Is féidir leis an modh seo foclóir go hiomlán difriúil a thabhairt ar ais más mian leis, a úsáidfear mar an `cleaned_data`. Ós rud é go bhfuil na modhanna bailíochtaithe réimse á reáchtáil faoin am a dtugtar ```clean () ``, tá rochtain agat freisin ar thréith ``earráidí``` na foirme ina bhfuil na hearráidí go léir a ardaítear trí ghlanadh réimsí aonair. Tabhair faoi deara nach mbeidh baint ag aon earráidí a ardóidh sé:meth: Form.clean () \`le haon réimse go háirithe. Téann siad isteach i “réimse” speisialta (ar a dtugtar \`\`\_\_all\_\_\`), ar féidir leat rochtain a fháil tríd an modh:meth: ~django.forms.form.NON\_FIELD\_ERRORS más gá duit. Más mian leat earráidí a cheangal le réimse ar leith san fhoirm, ní mór duit glaoch ar: meth: ~django.forms.form.add\_error () . Tabhair faoi deara freisin go bhfuil breithnithe speisialta ann agus an modh clean () de fho-aicme ModelForm a shárú. (féach an:ref: Doiciméadú ModelForm \\`le haghaidh tuilleadh eolais) Reáchtáiltear na modhanna seo san ord a thugtar thuas, réimse amháin ag an am. \Is é sin, i gcás gach réimse san fhoirm (san ord a dhearbhaítear iad sa mhíniú foirme), reáchtáiltear an modh `Field.clean ()` (nó a shárú), ansin () . Faoi dheireadh, nuair a bheidh an dá mhodh sin á reáchtáil do gach réimse, déantar an modh:meth: Form.clean () , nó a shárú, a fhorghníomhú cibé acu tá earráidí ardaithe ag na modhanna roimhe seo nó nach bhfuil. Tá samplaí de gach ceann de na modhanna seo ar fáil thíos. Mar a luadh, is féidir le haon cheann de na modhanna seo `Error Validationer` a ardú. Maidir le haon réimse, má ardaíonn an modh ````Field.clean () ```Error validation````, ní ghlaofar aon mhodh glantacháin réimsiú-shonrach. Mar sin féin, déantar na modhanna glantacháin do gach réimse atá fágtha i bhfeidhm fós. ## “Earráid Bailíochtaithe” a ardú D'fhonn teachtaireachtaí earráide a dhéanamh solúbtha agus éasca le frithdhíriú, smaoinigh ar na treoirlínte - Soláthar earráid tuairisciúil cód don tógálaí: ``` # Good ValidationError(_("Invalid value"), code="invalid") # Bad ValidationError(_("Invalid value")) ``` - Ná cuir athróga isteach sa teachtaireacht; bain úsáid as sealbhóirí agus argóint params' an tógálaí: ``` # Good ValidationError( _("Invalid value: %(value)s"), params={"value": "42"}, ) # Bad ValidationError(_("Invalid value: %s") % value) ``` - Úsáid eochracha mapála in ionad formáidiú suímh. Cuireann sé seo ar chumas na hathróga a chur in aon ord nó iad a fhágáil ar fad agus an teachtaireacht á athscríobh: ``` # Good ValidationError( _("Invalid value: %(value)s"), params={"value": "42"}, ) # Bad ValidationError( _("Invalid value: %s"), params=("42",), ) ``` - Fill an teachtaireacht le `gettext` chun aistriúchán a chumasú: ``` # Good ValidationError(_("Invalid value")) # Bad ValidationError("Invalid value") ``` Ag cur é ar fad le chéile: ``` raise ValidationError( _("Invalid value: %(value)s"), code="invalid", params={"value": "42"}, ) ``` Is gá go háirithe na treoirlínte seo a leanúint má scríobhann tú foirmeacha in-athúsáidte, réimsí foirme Cé nach mholtar, má tá tú ag deireadh an slabhra bailíochtaithe (ie do mhodh glan () foirm) agus má tá a fhios agat nach gcaithfidh tú *riam* do theachtaireacht earráide a shárú is féidir leat an rud is lú fós a roghnú: ``` ValidationError(_("Invalid value: %s") % value) ``` \Baineann na modhanna: Meth: Form.errors.as\_data () agus:meth: Form.error\ s.as\_json () leas mór as `ValidationError`s atá le feiceáil go hiomlán (le hainm ``cód `agus foclóir `params``). ### Earráidí iomadúla a ardú Má aimsíonn tú earráidí iolracha le linn modh glantacháin agus má theastaíonn uait iad go léir a chomharthú chuig an aighdeoir foirme, is féidir liosta earráidí a chur ar aghaidh chuig an tógálaí ValidationError. Mar atá thuas, moltar liosta de chásanna `ValidationError` a rith le ```cód ``\ s agus `params``` ach oibreoidh liosta teaghráin freisin: ``` # Good raise ValidationError( [ ValidationError(_("Error 1"), code="error1"), ValidationError(_("Error 2"), code="error2"), ] ) # Bad raise ValidationError( [ _("Error 1"), _("Error 2"), ] ) ``` ## Bailíochtú a úsáid i gcleachtas Mhínigh na hailt roimhe seo conas a oibríonn bailíochtú i gcoitinne le haghaidh Ós rud é go bhféadfadh sé a bheith níos éasca uaireanta rudaí a chur i bhfeidhm trí gach gné atá in úsáid a fheiceáil, seo sraith samplaí beaga a úsáideann gach ceann de na gnéithe roimhe seo. ### Bailíochtóirí a úsáid Tacaíonn réimsí foirme (agus samhail) Django le húsáid feidhmeanna fóntais agus ranganna ar a dtugtar bailíochtóirí. Is réad nó feidhm inghlaonta é bailíochtaitheoir a thógann luach agus nach dtugann aon rud ar ais má tá an luach bailí nó má ardaíonn a:exc: ~django.core.exceptions.validationError mura bhfuil. Is féidir iad seo a chur chuig tógálaí réimse, trí argóint ```validators ``an réimse, nó a shainiú ar aicme:class: `~django.forms.field` féin leis an tréith ``default_validators```. Is féidir bailíochtóirí a úsáid chun luachanna taobh istigh den réimse a bhailíochtú, déanaimis féachaint ar Slugfield\` Django: ``` from django.core import validators from django.forms import CharField class SlugField(CharField): default_validators = [validators.validate_slug] ``` Mar a fheiceann tú, is ```Charfield` é ``Slugfield``` le bailíochtóir saincheaptha a bhailíochnaíonn go gcloíonn an téacs curtha isteach do roinnt rialacha carachtar. Is féidir é seo a dhéanamh freisin ar an sainmhíniú allamuigh mar sin: ``` slug = forms.SlugField() ``` atá coibhéiseach le: ``` slug = forms.CharField(validators=[validators.validate_slug]) ``` Common cases such as validating against an email or a regular expression can be handled using existing validator classes available in Django. For example, `validators.validate_slug` is an instance of a [`RegexValidator`](/ga/5.2/ref/validators/#django.core.validators.RegexValidator) constructed with the first argument being the pattern: `^[-a-zA-Z0-9_]+\Z`. See the section on [writing validators](/ga/5.2/ref/validators/) to see a list of what is already available and for an example of how to write a validator. ### Glanadh réamhshocraithe réimse Déanaimis réimse foirme saincheaptha a chruthú ar dtús a bhailíochnaíonn a ionchur ná sreang ina bhfuil seoltaí ríomhphoist scartha le camóg. Breathnaíonn an rang iomlán mar seo: ``` from django import forms from django.core.validators import validate_email class MultiEmailField(forms.Field): def to_python(self, value): """Normalize data to a list of strings.""" # Return an empty list if no input was given. if not value: return [] return value.split(",") def validate(self, value): """Check if value consists only of valid emails.""" # Use the parent's handling of required fields, etc. super().validate(value) for email in value: validate_email(email) ``` Beidh na modhanna seo á reáchtáil ag gach foirm a úsáideann an réimse seo sula bhféadfar aon rud eile a dhéanamh le sonraí an réimse. Is glanadh é seo atá sonrach don chineál seo réimse, beag beann ar an gcaoi a n-úsáidtear é ina dhiaidh sin. Cruthaímid `Foirm Teagmhála` chun a thaispeáint conas a úsáideann tú an réimse seo: ``` class ContactForm(forms.Form): subject = forms.CharField(max_length=100) message = forms.CharField() sender = forms.EmailField() recipients = MultiEmailField() cc_myself = forms.BooleanField(required=False) ``` Úsáid `Multiemailfield` cosúil le haon réimse foirme eile. Nuair a ghlaofar an modh ```is_valid () ``ar an bhfoirm, reáchtálfar an modh ``multiemailfield.clean ()``` mar chuid den phróiseas glantacháin agus glaóidh sé, ina dhiaidh sin, na modhanna saincheaptha ```to_python () ``agus ``validate ()```. ### Glanadh tréith réimse ar leith Ag leanúint ar aghaidh ón sampla roimhe seo, cuir i gcás gur mhaith linn a chinntiú go bhfuil an seoladh `” fred@example.com “` sa réimse faighteoirí i gcónaí. Is bailíochtú é seo atá sonrach dár bhfoirm, mar sin níl muid ag iarraidh é a chur isteach sa rang ginearálta Multiemailfield\`. Ina áit sin, scríobhaimid modh glantacháin a oibríonn ar an réimse faighteoirí , mar sin: ``` from django import forms from django.core.exceptions import ValidationError class ContactForm(forms.Form): # Everything as before. ... def clean_recipients(self): data = self.cleaned_data["recipients"] if "fred@example.com" not in data: raise ValidationError("You have forgotten about Fred!") # Always return a value to use as the new cleaned data, even if # this method didn't change it. return data ``` ### Réimsí a ghlanadh agus a bhailíochtú atá ag brath ar a chéile Cuirimid riachtanas eile lenár bhfoirm teagmhála: más é “Fíor” sa réimse cc\_myself\`, ní mór go mbeadh an focal ```"cabhrach"` sa `ábhar ``. Táimid ag déanamh bailíochtaithe ar níos mó ná réimse amháin ag an am, mar sin is áit mhaith é an modh foirm: meth: `~form.clean () `chun é seo a dhéanamh. Tabhair faoi deara go bhfuilimid ag caint faoin modh ``clean () ``ar an bhfoirm anseo, ach níos luaithe bhí modh ``clean ()``` á scríobh againn ar réimse. Tá sé tábhachtach an réimse agus an difríocht foirme a choinneáil soiléir agus tú ag obair amach cá háit le rudaí a bhail Is pointí sonraí aonair iad réimsí, is bailiúchán réimsí iad foirmeacha. Faoin am a dtugtar modh ```clean () ``ar an bhfoirm, beidh na modhanna glan réimse aonair go léir á reáchtáil (an dá chuid roimhe seo), mar sin déanfar ``self.cleaned_data``` daonra le haon sonraí a tháinig maireachtáil go dtí seo. Mar sin ní mór duit cuimhneamh freisin a cheadú go mb'fhéidir nár mhair na réimsí atá tú ag iarraidh a bhailíochtú sna seiceálacha réimse aonair tosaigh. Tá dhá bhealach ann chun aon earráidí ón gcéim seo a thuairisciú. Is dócha gurb é an modh is coitianta an earráid a thaispeáint ag barr na foirme. Chun earráid den sórt sin a chruthú, is féidir leat `ValidationError` a ardú ón modh clean () . Mar shampla: ``` from django import forms from django.core.exceptions import ValidationError class ContactForm(forms.Form): # Everything as before. ... def clean(self): cleaned_data = super().clean() cc_myself = cleaned_data.get("cc_myself") subject = cleaned_data.get("subject") if cc_myself and subject: # Only do something if both fields are valid so far. if "help" not in subject: raise ValidationError( "Did not send for 'help' in the subject despite CC'ing yourself." ) ``` Sa chód seo, má ardaítear an earráid bailíochtaithe, taispeánfaidh an fhoirm teachtaireacht earráide ag barr na foirme (de ghnáth) ag cur síos ar an bhfadhb. Is earráidí neamh-réimse iad earráidí den sórt sin, a thaispeántar sa teimpléad le `{{form.non_field_errors}}`. Cinntíonn an glao chuig ```super () .clean () ``sa chód samplaí go gcoinnítear aon loighic bailíochtaithe i ranganna tuismitheoirí. Má tá foirm eile ag d'oidhreacht nach gcuireann foclóir ``cleaned_data ``ar ais ina modh ``clean ()``` (is roghnach é sin a dhéanamh), ansin ná sannadh `cleaned_data` do thoradh an ghlaonna ```super () ``agus bain úsáid as ``self.cleaned_data``` ina ionad: ``` def clean(self): super().clean() cc_myself = self.cleaned_data.get("cc_myself") ... ``` D'fhéadfadh sé go mbeadh an teachtaireacht earráide a shannadh chuig ceann de na réimsí leis an dara cur chuige chun earráidí bailíochtaithe Sa chás seo, déanaimis teachtaireacht earráide a shannadh do na sraitheanna “ábhar” agus “cc\_myself” araon sa taispeáint foirme. Bí cúramach agus é seo á dhéanamh go praiticiúil, ós rud é go bhféadfadh aschur foirme mearbhall a bheith mar thoradh Táimid ag taispeáint cad is féidir anseo agus táimid ag fágáil ort féin agus do dhearthóirí é a oibriú amach cad a oibríonn go héifeachtach i do chás áirithe. Tá cuma seo ar ár gcód nua (in ionad an tsampla roimhe seo): ``` from django import forms class ContactForm(forms.Form): # Everything as before. ... def clean(self): cleaned_data = super().clean() cc_myself = cleaned_data.get("cc_myself") subject = cleaned_data.get("subject") if cc_myself and subject and "help" not in subject: msg = "Must put 'help' in subject when cc'ing yourself." self.add_error("cc_myself", msg) self.add_error("subject", msg) ``` Is féidir leis an dara argóint de ```add_error () ``a bheith ina shreang, nó b'fhéidir mar shampla de ``ValidationError```. Féach:ref: raising-validation-error le haghaidh tuilleadh sonraí. Tabhair faoi deara go mbaineann ```add_error () ``an réimse go huathoibríoch ó ``cleaned_data```.