---
title: "Formulärfält"
version: 6.1
locale: sv
source: https://docs.djangoproject.com/sv/6.1/ref/forms/fields/
canonical: https://djangodocs.dev/sv/6.1/ref/forms/fields/
---
# Formulärfält
#### `class Field`
När du skapar en `Form`-klass är den viktigaste delen att definiera fälten i formuläret. Varje fält har en anpassad valideringslogik, tillsammans med några andra hooks.
#### `Field.clean(value)`
Även om det primära sättet du kommer att använda `Field`-klasser är i `Form`-klasser, kan du också instansiera dem och använda dem direkt för att få en bättre uppfattning om hur de fungerar. Varje `Field`-instans har en `clean()`-metod, som tar ett enda argument och antingen ger upphov till ett `django.core.exceptions.ValidationError`-undantag eller returnerar det rena värdet:
```pycon
>>> from django import forms
>>> f = forms.EmailField()
>>> f.clean("foo@example.com")
'foo@example.com'
>>> f.clean("invalid email address")
Traceback (most recent call last):
...
ValidationError: ['Enter a valid email address.']
```
## Argument för kärnområdet
Varje `Field`-klass konstruktör tar minst dessa argument. Vissa `Field`-klasser tar ytterligare fältspecifika argument, men följande bör *alltid* accepteras:
### `krävs`
#### `Field.required`
Som standard antar varje `Field`-klass att värdet är obligatoriskt, så om du skickar ett tomt värde - antingen `None` eller den tomma strängen (`""`) - kommer `clean()` att ge upphov till ett `ValidationError` undantag:
```pycon
>>> from django import forms
>>> f = forms.CharField()
>>> f.clean("foo")
'foo'
>>> f.clean("")
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
>>> f.clean(None)
Traceback (most recent call last):
...
ValidationError: ['This field is required.']
>>> f.clean(0)
'0'
>>> f.clean(True)
'True'
>>> f.clean(False)
'False'
```
För att ange att ett fält *inte* är obligatoriskt, skicka `required=False` till konstruktören `Field`:
```pycon
>>> f = forms.CharField(required=False)
>>> f.clean("foo")
'foo'
>>> f.clean("")
''
>>> f.clean(None)
''
>>> f.clean(0)
'0'
>>> f.clean(True)
'True'
>>> f.clean(False)
'False'
```
Om en `Field` har `required=False` och du ger `clean()` ett tomt värde, så kommer `clean()` att returnera ett *normaliserat* tomt värde istället för att ge upphov till `ValidationError`. För `CharField` kommer detta att returnera [`empty_value`](#django.forms.CharField.empty_value) som standard är en tom sträng. För andra klasser av `Field` kan det vara `None`. (Detta varierar från fält till fält.)
Widgets för obligatoriska formulärfält har HTML-attributet `required`. Ställ in attributet [`Form.use_required_attribute`](/sv/6.1/ref/forms/api/#django.forms.Form.use_required_attribute) till `False` för att inaktivera det. Attributet `required` ingår inte i formulär för formuläruppsättningar eftersom webbläsarens validering kanske inte är korrekt när formuläruppsättningar läggs till och tas bort.
### `etikett`
#### `Field.label`
Med argumentet `label` kan du ange den ”människovänliga” etiketten för detta fält. Detta används när `Field` visas i en `Form`.
As explained in [Utmatning av formulär som HTML](/sv/6.1/ref/forms/api/#ref-forms-api-outputting-html), the default label for a
`Field` is generated from the field name by converting all underscores to
spaces and upper-casing the first letter. Specify a string for `label` if
that default behavior doesn’t result in an adequate label. Use an empty string
(`""`) to hide the label.
Här är ett fullständigt exempel på `Form` som implementerar `label` för två av sina fält. Vi har angett `auto_id=False` för att förenkla utdata:
```pycon
>>> from django import forms
>>> class CommentForm(forms.Form):
... name = forms.CharField(label="Your name")
... url = forms.URLField(label="Your website", required=False)
... comment = forms.CharField()
...
>>> f = CommentForm(auto_id=False)
>>> print(f)
Your name:
Your website:
Comment:
```
### `label_suffix`
#### `Field.label_suffix`
Med argumentet `label_suffix` kan du åsidosätta formulärets [`label_suffix`](/sv/6.1/ref/forms/api/#django.forms.Form.label_suffix) för varje enskilt fält:
```pycon
>>> class ContactForm(forms.Form):
... age = forms.IntegerField()
... nationality = forms.CharField()
... captcha_answer = forms.IntegerField(label="2 + 2", label_suffix=" =")
...
>>> f = ContactForm(label_suffix="?")
>>> print(f)
```
### `initial`
#### `Field.initial`
Med argumentet `initial` kan du ange det initiala värde som ska användas när detta `Field` återges i ett obundet `Form`.
För att ange dynamiska initialdata, se parametern [`Form.initial`](/sv/6.1/ref/forms/api/#django.forms.Form.initial).
Användningsfallet för detta är när du vill visa ett ”tomt” formulär där ett fält är initialiserat till ett visst värde. Ett exempel:
```pycon
>>> from django import forms
>>> class CommentForm(forms.Form):
... name = forms.CharField(initial="Your name")
... url = forms.URLField(initial="https://")
... comment = forms.CharField()
...
>>> f = CommentForm(auto_id=False)
>>> print(f)
Name:
Url:
Comment:
```
Du kanske tänker, varför inte bara skicka en ordbok med de ursprungliga värdena som data när du visar formuläret? Tja, om du gör det kommer du att utlösa validering och HTML-utdata kommer att innehålla eventuella valideringsfel:
```pycon
>>> class CommentForm(forms.Form):
... name = forms.CharField()
... url = forms.URLField()
... comment = forms.CharField()
...
>>> default_data = {"name": "Your name", "url": "https://"}
>>> f = CommentForm(default_data, auto_id=False)
>>> print(f)
Name:
Url:
Enter a valid URL.
Comment:
This field is required.
```
Det är därför som ”initial”-värden bara visas för obundna formulär. För bundna formulär kommer HTML-utdata att använda de bundna uppgifterna.
Observera också att ”initiala” värden *inte* används som ”fallback”-data vid validering om värdet för ett visst fält inte anges. `initial`-värden är *endast* avsedda för initial visning av formuläret:
```pycon
>>> class CommentForm(forms.Form):
... name = forms.CharField(initial="Your name")
... url = forms.URLField(initial="https://")
... comment = forms.CharField()
...
>>> data = {"name": "", "url": "", "comment": "Foo"}
>>> f = CommentForm(data)
>>> f.is_valid()
False
# The form does *not* fallback to using the initial values.
>>> f.errors
{'url': ['This field is required.'], 'name': ['This field is required.']}
```
I stället för en konstant kan du också skicka en valfri callable:
```pycon
>>> import datetime
>>> class DateForm(forms.Form):
... day = forms.DateField(initial=datetime.date.today)
...
>>> print(DateForm())
```
Callable kommer att utvärderas först när det obundna formuläret visas, inte när det definieras.
### `widget`
#### `Field.widget`
Med argumentet `widget` kan du ange en `Widget`-klass som ska användas vid rendering av detta `Field`. Se [Widgets](/sv/6.1/ref/forms/widgets/) för mer information.
### `hjälp_text`
#### `Field.help_text`
Med argumentet `help_text` kan du ange en beskrivande text för detta `Field`. Om du anger `help_text` kommer den att visas bredvid `Field` när `Field` återges med en av de praktiska `Form`-metoderna (t.ex. `as_ul()`).
Precis som modellfältets [`help_text`](/sv/6.1/ref/models/fields/#django.db.models.Field.help_text), är detta värde inte HTML-escaped i automatiskt genererade formulär.
Här är ett fullständigt exempel på en `Form` som implementerar `help_text` för två av sina fält. Vi har angett `auto_id=False` för att förenkla utdata:
```pycon
>>> from django import forms
>>> class HelpTextContactForm(forms.Form):
... subject = forms.CharField(max_length=100, help_text="100 characters max.")
... message = forms.CharField()
... contact_email = forms.EmailField(help_text="Your email (so we can reply).")
...
>>> f = HelpTextContactForm(auto_id=False)
>>> print(f)
Subject:
100 characters max.
Message:
Contact email:
Your email (so we can reply).
```
När ett fält har en hjälptext associeras den med dess inmatning med hjälp av HTML-attributet `aria-describedby`. Om widgeten återges i en `