# Django 6.0.5 documentation

# Validerare

## Skriva validatorer

En validator är en anropsbar som tar ett värde och skapar ett `ValidationError` om det inte uppfyller vissa kriterier. Validerare kan vara användbara för att återanvända valideringslogik mellan olika typer av fält.

Här är till exempel en validator som bara tillåter jämna tal:

    from django.core.exceptions import ValidationError
    from django.utils.translation import gettext_lazy as _

    def validate_even(value):
        if value % 2 != 0:
            raise ValidationError(
                _("%(value)s is not an even number"),
                params={"value": value},
            )

Du kan lägga till detta i ett modellfält via fältets `validators` argument:

    from django.db import models

    class MyModel(models.Model):
        even_field = models.IntegerField(validators=[validate_even])

Eftersom värden konverteras till Python innan validatorerna körs kan du till och med använda samma validator med formulär:

    from django import forms

    class MyForm(forms.Form):
        even_field = forms.IntegerField(validators=[validate_even])

Du kan också använda en klass med en `__call__()`-metod för mer komplexa eller konfigurerbara validerare. `RegexValidator`, till exempel, använder denna teknik. Om en klassbaserad validerare används i modellfältalternativet `validators` bör du se till att den är serialiserbar av migreringsramverket genom att lägga till deconstruct() och `__eq__()`-metoder.

## Hur validerare körs

Se formulärvalidering för mer information om hur validerare körs i formulär, och Validering av objekt för hur de körs i modeller. Observera att validerare inte kommer att köras automatiskt när du sparar en modell, men om du använder en `ModelForm`, kommer den att köra dina validerare på alla fält som ingår i ditt formulär. Se ModelForm-dokumentationen för information om hur modellvalidering interagerar med formulär.

## Inbyggda validerare

Modulen `django.core.validators` innehåller en samling anropsbara validatorer för användning med modell- och formulärfält. De används internt men är tillgängliga för användning med dina egna fält också. De kan användas utöver eller i stället för anpassade `field.clean()`-metoder.

### `RegexValidator`

class RegexValidator(regex=None, message=None, code=None, inverse_match=None, flags=0)
  Parametrar:

    - regex – Om inte `None`, åsidosätter `regex`. Kan vara en sträng med ett reguljärt uttryck eller ett förkompilerat reguljärt uttryck.

    - message – Om inte `None`, åsidosätter `message`.

    - code – Om inte `None`, åsidosätter `code`.

    - inverse_match – Om inte `None`, åsidosätter `inverse_match`.

    - flags – Om inte `None`, åsidosätter `flags`. I så fall måste `regex` vara en sträng med ett reguljärt uttryck, annars uppstår `TypeError`.

  En `RegexValidator` söker i det angivna `värdet` efter ett givet reguljärt uttryck med `re.search()`. Som standard uppstår ett `ValidationError` med `message` och `code` om en matchning inte hittas. Dess beteende kan inverteras genom att sätta `inverse_match` till `True`, i vilket fall `ValidationError` utlöses när en matchning finns.

  regex

    Det reguljära uttrycksmönstret som ska sökas efter i det angivna `värdet`, med `re.search()`. Detta kan vara en sträng eller ett förkompilerat reguljärt uttryck skapat med `re.compile()`. Standardvärdet är den tomma strängen, som kommer att hittas i alla möjliga `värden`.

  message

    Det felmeddelande som används av `ValidationError` om valideringen misslyckas. Standardvärdet är `"Ange ett giltigt värde"`.

  code

    Den felkod som används av `ValidationError` om valideringen misslyckas. Standardvärdet är `"invalid"`.

  inverse_match

    Matchningsläge för `regex`. Standardvärdet är `False`.

  flags

    Flaggorna för regex som används när strängen för reguljära uttryck `regex` kompileras. Om `regex` är ett förkompilerat reguljärt uttryck, och `flags` åsidosätts, uppstår `TypeError`. Standardvärde är `0`.

### `EmailValidator`

class EmailValidator(message=None, code=None, allowlist=None)
  Parametrar:

    - message – Om inte `None`, åsidosätter `message`.

    - code – Om inte `None`, åsidosätter `code`.

    - allowlist – Om inte `None`, åsidosätter `allowlist`.

  An `EmailValidator` ensures that a value looks like an email address, and raises a `ValidationError` with `message` and `code` if it doesn’t. Values longer than 320 characters are always considered invalid.

  message

    Det felmeddelande som används av `ValidationError` om valideringen misslyckas. Standard är `"Ange en giltig e-postadress"`.

  code

    Den felkod som används av `ValidationError` om valideringen misslyckas. Standardvärdet är `"invalid"`.

  allowlist

    Tillåtlista över e-postdomäner. Som standard används ett reguljärt uttryck (attributet `domain_regex`) för att validera allt som visas efter tecknet `@`. Men om den strängen finns med i `allowlist`, kringgås denna validering. Om den inte anges är standardvärdet för `allowlist` `['localhost']`. Andra domäner som inte innehåller en punkt kommer inte att klara valideringen, så du måste lägga till dem i `allowlist` vid behov.

### `DomainNameValidator`

class DomainNameValidator(accept_idna=True, message=None, code=None)

  En `RegexValidator`-underklass som säkerställer att ett värde ser ut som ett domännamn. Värden som är längre än 255 tecken betraktas alltid som ogiltiga. IP-adresser accepteras inte som giltiga domännamn.

  Utöver de valfria argumenten i sin överordnade klass `RegexValidator` accepterar `DomainNameValidator` ett extra valfritt attribut:

  accept_idna

    Avgör om internationaliserade domännamn ska accepteras, dvs. domännamn som innehåller icke-ASCII-tecken. Standardvärdet är `True`.

### `URLValidator`

class URLValidator(schemes=None, regex=None, message=None, code=None)

  En `RegexValidator`-underklass som säkerställer att ett värde ser ut som en URL, och ger felkoden `'invalid` om det inte gör det. Värden som är längre än `max_length` tecken betraktas alltid som ogiltiga.

  Loopback-adresser och reserverade IP-utrymmen betraktas som giltiga. Både bokstavliga IPv6-adresser (RFC 3986 Section 3.2.2) och Unicode-domäner stöds.

  Utöver de valfria argumenten i sin överordnade klass `RegexValidator` accepterar `URLValidator` ett extra valfritt attribut:

  schemes

    Lista över URL/URI-scheman att validera mot. Om den inte anges är standardlistan `['http', 'https', 'ftp', 'ftps']`. Som referens finns på IANA:s webbplats en fullständig lista över giltiga URI-scheman.

    Varning

    Värden som börjar med `file:///` kommer inte att godkännas även om `file`-schema anges. Giltiga värden måste innehålla en host.

  max_length

    Den maximala längden på värden som kan anses vara giltiga. Standardvärdet är 2048 tecken.

### `validera_email`

validate_email

  En `EmailValidator`-instans utan några anpassningar.

### `validera_domännamn`

validate_domain_name

  En `DomainNameValidator`-instans utan några anpassningar.

### `validera_slug`

validate_slug

  En instans av `RegexValidator` som säkerställer att ett värde endast består av bokstäver, siffror, understreck eller bindestreck.

### `validera_unicode_slug`

validate_unicode_slug

  En instans av `RegexValidator` som säkerställer att ett värde endast består av Unicode-bokstäver, siffror, understreck eller bindestreck.

### `validera_ipv4_adress`

validate_ipv4_address

  En `RegexValidator`-instans som säkerställer att ett värde ser ut som en IPv4-adress.

### `validera_ipv6_adress`

validate_ipv6_address

  Använder `django.utils.ipv6` för att kontrollera giltigheten för en IPv6-adress.

### `validera_ipv46_adress`

validate_ipv46_address

  Använder både `validate_ipv4_address` och `validate_ipv6_address` för att säkerställa att ett värde är antingen en giltig IPv4- eller IPv6-adress.

### `validera_kommaseparerad_talslista`

validate_comma_separated_integer_list

  En instans av `RegexValidator` som säkerställer att ett värde är en kommaseparerad lista med heltal.

### `int_list_validator`

int_list_validator(sep=',', message=None, code='invalid', allow_negative=False)

  Returnerar en instans av `RegexValidator` som säkerställer att en sträng består av heltal separerade med `sep`. Den tillåter negativa heltal när `allow_negative` är `True`.

### `MaxValueValidator`

class MaxValueValidator(limit_value, message=None)

  Utlöser ett `ValidationError` med koden `'max_value'` om `value` är större än `limit_value`, som kan vara en anropbar.

### `MinValueValidator`

class MinValueValidator(limit_value, message=None)

  Utlöser ett `ValidationError` med koden `'min_value'` om `value` är mindre än `limit_value`, som kan vara en anropbar.

### `MaxLengthValidator`

class MaxLengthValidator(limit_value, message=None)

  Utlöser ett `ValidationError` med koden `'max_length'` om längden på `value` är större än `limit_value`, som kan vara en anropbar.

### `MinLengthValidator`

class MinLengthValidator(limit_value, message=None)

  Utlöser ett `ValidationError` med koden `'min_length'` om längden på `value` är mindre än `limit_value`, som kan vara en anropbar.

### `DecimalValidator`

class DecimalValidator(max_digits, decimal_places)

  Utlöser `ValidationError` med följande koder:

  - `'max_digits'` om antalet siffror är större än `max_digits`.

  - `'max_decimal_places'` om antalet decimaler är större än `decimal_places`.

  - `'max_whole_digits'` om antalet hela siffror är större än skillnaden mellan `max_digits` och `decimal_places`.

### `FileExtensionValidator`

class FileExtensionValidator(allowed_extensions, message, code)

  Utlöser ett `ValidationError` med koden `'invalid_extension'` om tillägget till `value.name` (`value` är en `File`) inte finns i `allowed_extensions`. Tillägget jämförs fall-insensitivt med `allowed_extensions`.

  Varning

  Förlita dig inte på validering av filtillägget för att avgöra en fils typ. Filer kan döpas om så att de får vilket filnamnstillägg som helst, oavsett vilka data de innehåller.

### `validera_bild_fil_utvidgning`

validate_image_file_extension

  Uses Pillow to ensure that `value.name` (`value` is a `File`) has a valid image extension.

### `ProhibitNullCharactersValidator`

class ProhibitNullCharactersValidator(message=None, code=None)

  Utlöser ett `ValidationError` om `str(value)` innehåller ett eller flera nolltecken (`'\x00'`).

  Parametrar:

    - message – Om inte `None`, åsidosätter `message`.

    - code – Om inte `None`, åsidosätter `code`.

  message

    Det felmeddelande som används av `ValidationError` om valideringen misslyckas. Standard är `"Null-tecken är inte tillåtna."`.

  code

    Den felkod som används av `ValidationError` om valideringen misslyckas. Standardvärdet är `"null_characters_not_allowed"`.

### `StepValueValidator`

class StepValueValidator(limit_value, message=None, offset=None)

  Utlöser ett `ValidationError` med koden `'step_size'` om `value` inte är en integrerad multipel av `limit_value`, som kan vara ett flottör-, heltal- eller decimalvärde eller en callable. När `offset` är inställt sker valideringen mot `limit_value` plus `offset`. Till exempel:, för `StepValueValidator(3, offset=1.4)` inkluderar giltiga värden `1.4`, `4.4`, `7.4`, `10.4`, och så vidare.