Altri validatori

Sono disponibili molti validatori in Composer che possono essere utilizzati direttamente, ad esempio:

webman/validation (Consigliato)

top-think/think-validate

respect/validation

Validatore webman/validation

Basato su illuminate/validation, fornisce validazione manuale, validazione tramite annotazioni, validazione a livello di parametro e set di regole riutilizzabili.

Installazione

composer require webman/validation

Concetti di base

• Riuso dei set di regole: Definire rules, messages, attributes e scenes riutilizzabili estendendo support\validation\Validator, che possono essere riutilizzati sia nella validazione manuale che in quella tramite annotazioni.
• Validazione tramite annotazione (attributo) a livello di metodo: Utilizzare l'attributo PHP 8 #[Validate] per associare la validazione ai metodi del controller.
• Validazione tramite annotazione (attributo) a livello di parametro: Utilizzare l'attributo PHP 8 #[Param] per associare la validazione ai parametri dei metodi del controller.
• Gestione delle eccezioni: Lancia support\validation\ValidationException in caso di fallimento della validazione; la classe dell'eccezione è configurabile.
• Validazione database: Se è coinvolta la validazione del database, è necessario installare composer require webman/database.

Validazione manuale

Utilizzo di base

use support\validation\Validator;

$data = ['email' => 'user@example.com'];

Validator::make($data, [
    'email' => 'required|email',
])->validate();

Nota
validate() lancia support\validation\ValidationException quando la validazione fallisce. Se preferisci non lanciare eccezioni, utilizza l'approccio fails() descritto di seguito per ottenere i messaggi di errore.

Messaggi e attributi personalizzati

use support\validation\Validator;

$data = ['contact' => 'user@example.com'];

Validator::make(
    $data,
    ['contact' => 'required|email'],
    ['contact.email' => 'Formato email non valido'],
    ['contact' => 'Email']
)->validate();

Validare senza eccezione (ottenere messaggi di errore)

Se preferisci non lanciare eccezioni, utilizza fails() per verificare e ottenere i messaggi di errore tramite errors() (restituisce MessageBag):

use support\validation\Validator;

$data = ['email' => 'bad-email'];

$validator = Validator::make($data, [
    'email' => 'required|email',
]);

if ($validator->fails()) {
    $firstError = $validator->errors()->first();      // string
    $allErrors = $validator->errors()->all();         // array
    $errorsByField = $validator->errors()->toArray(); // array
    // gestire gli errori...
}

Riuso dei set di regole (validatore personalizzato)

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $messages = [
        'name.required' => 'Il nome è obbligatorio',
        'email.required' => 'L\'email è obbligatoria',
        'email.email' => 'Formato email non valido',
    ];

    protected array $attributes = [
        'name' => 'Nome',
        'email' => 'Email',
    ];
}

Riuso nella validazione manuale

use app\validation\UserValidator;

UserValidator::make($data)->validate();

Utilizzo delle scene (opzionale)

scenes è una funzionalità opzionale; valida solo un sottoinsieme di campi quando si chiama withScene(...).

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $scenes = [
        'create' => ['name', 'email'],
        'update' => ['id', 'name', 'email'],
    ];
}

use app\validation\UserValidator;

// Nessuna scena specificata -> valida tutte le regole
UserValidator::make($data)->validate();

// Scena specificata -> valida solo i campi di quella scena
UserValidator::make($data)->withScene('create')->validate();

Validazione tramite annotazioni (livello metodo)

Regole dirette

use support\Request;
use support\validation\annotation\Validate;

class AuthController
{
    #[Validate(
        rules: [
            'email' => 'required|email',
            'password' => 'required|string|min:6',
        ],
        messages: [
            'email.required' => 'L\'email è obbligatoria',
            'password.required' => 'La password è obbligatoria',
        ],
        attributes: [
            'email' => 'Email',
            'password' => 'Password',
        ]
    )]
    public function login(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Riuso dei set di regole

use app\validation\UserValidator;
use support\Request;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(validator: UserValidator::class, scene: 'create')]
    public function create(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Sovrapposizioni multiple di validazione

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['email' => 'required|email'])]
    #[Validate(rules: ['token' => 'required|string'])]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Sorgente dati per la validazione

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(
        rules: ['email' => 'required|email'],
        in: ['query', 'body', 'path']
    )]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Utilizzare il parametro in per specificare la sorgente dei dati:

• query parametri query della richiesta HTTP, da $request->get()
• body corpo della richiesta HTTP, da $request->post()
• path parametri path della richiesta HTTP, da $request->route->param()

in può essere una stringa o un array; quando è un array, i valori vengono uniti in ordine con i valori successivi che sovrascrivono quelli precedenti. Quando in non viene passato, il valore predefinito è ['query', 'body', 'path'].

Validazione a livello di parametro (Param)

Utilizzo di base

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|email')] string $to,
        #[Param(rules: 'required|string|min:1|max:500')] string $content
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Sorgente dati per la validazione

Analogamente, la validazione a livello di parametro supporta anche il parametro in per specificare la sorgente:

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email', in: ['body'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

rules supporta stringa o array

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: ['required', 'email'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Messaggi / attributo personalizzati

use support\validation\annotation\Param;

class UserController
{
    public function updateEmail(
        #[Param(
            rules: 'required|email',
            messages: ['email.email' => 'Formato email non valido'],
            attribute: 'Email'
        )]
        string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Riuso di costanti per le regole

final class ParamRules
{
    public const EMAIL = ['required', 'email'];
}

class UserController
{
    public function send(
        #[Param(rules: ParamRules::EMAIL)] string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Combinazione livello metodo + livello parametro

use support\Request;
use support\validation\annotation\Param;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['token' => 'required|string'])]
    public function send(
        Request $request,
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|integer')] int $id
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Inferenza automatica delle regole (basata sulla firma del parametro)

Quando #[Validate] viene utilizzato su un metodo, o qualsiasi parametro di quel metodo utilizza #[Param], questo componente inferisce e completa automaticamente le regole di validazione di base dalla firma del parametro del metodo, quindi le unisce con le regole esistenti prima della validazione.

Esempio: espansione equivalente di #[Validate]

1) Abilitare solo #[Validate] senza scrivere manualmente le regole:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content, int $uid)
    {
    }
}

Equivalente a:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

2) Solo regole parziali scritte, il resto completato dalla firma del parametro:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'min:2',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

Equivalente a:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string|min:2',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

3) Valore predefinito / tipo nullable:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Equivalente a:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'string',
        'uid' => 'integer|nullable',
    ])]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Gestione delle eccezioni

Eccezione predefinita

Il fallimento della validazione lancia support\validation\ValidationException per impostazione predefinita, che estende Webman\Exception\BusinessException e non registra gli errori.

Il comportamento di risposta predefinito è gestito da BusinessException::render():

• Richieste regolari: restituisce messaggio stringa, es. token is required.
• Richieste JSON: restituisce risposta JSON, es. {"code": 422, "msg": "token is required.", "data":....}

Personalizzare la gestione tramite eccezione personalizzata

• Configurazione globale: exception in config/plugin/webman/validation/app.php

Supporto multilingue

Il componente include pacchetti linguistici cinese e inglese integrati e supporta le sovrascritture del progetto. Ordine di caricamento:

1. Pacchetto linguistico del progetto resource/translations/{locale}/validation.php
2. Pacchetto linguistico integrato del componente vendor/webman/validation/resources/lang/{locale}/validation.php
3. Inglese integrato di Illuminate (fallback)

Nota
La lingua predefinita di Webman è configurata in config/translation.php, oppure può essere modificata tramite locale('en');.

Esempio di sovrascrittura locale

resource/translations/zh_CN/validation.php

return [
    'email' => ':attribute is not a valid email format.',
];

Caricamento automatico del middleware

Dopo l'installazione, il componente carica automaticamente il middleware di validazione tramite config/plugin/webman/validation/middleware.php; non è necessaria alcuna registrazione manuale.

Generazione da riga di comando

Utilizzare il comando make:validator per generare classi validatore (output predefinito nella directory app/validation).

Nota
Richiede composer require webman/console

Utilizzo di base

• Generare template vuoto

php webman make:validator UserValidator

• Sovrascrivere file esistente

php webman make:validator UserValidator --force
php webman make:validator UserValidator -f

Generare regole dalla struttura della tabella

• Specificare il nome della tabella per generare regole di base (inferisce $rules dal tipo di campo/nullable/lunghezza ecc.; esclude i campi relativi all'ORM per impostazione predefinita: laravel usa created_at/updated_at/deleted_at, thinkorm usa create_time/update_time/delete_time)

php webman make:validator UserValidator --table=wa_users
php webman make:validator UserValidator -t wa_users

• Specificare la connessione al database (scenari con più connessioni)

php webman make:validator UserValidator --table=wa_users --database=mysql
php webman make:validator UserValidator -t wa_users -d mysql

Scene

• Generare scene CRUD: create/update/delete/detail

php webman make:validator UserValidator --table=wa_users --scenes=crud
php webman make:validator UserValidator -t wa_users -s crud

La scena update include il campo chiave primaria (per individuare i record) più gli altri campi; delete/detail includono solo la chiave primaria per impostazione predefinita.

Selezione ORM (laravel (illuminate/database) vs think-orm)

• Selezione automatica (predefinita): Utilizza quello installato/configurato; quando entrambi esistono, utilizza illuminate per impostazione predefinita
• Forzare specifica

php webman make:validator UserValidator --table=wa_users --orm=laravel
php webman make:validator UserValidator --table=wa_users --orm=thinkorm
php webman make:validator UserValidator -t wa_users -o thinkorm

Esempio completo

php webman make:validator UserValidator -t wa_users -d mysql -s crud -o laravel -f

Test unitari

Dalla directory root di webman/validation, eseguire:

composer install
vendor\bin\phpunit -c phpunit.xml

Riferimento alle regole di validazione

Regole di validazione disponibili

[!IMPORTANT]

• Webman Validation è basato su illuminate/validation; i nomi delle regole corrispondono a Laravel e non ci sono regole specifiche di Webman.
• Il middleware valida i dati da $request->all() (GET+POST) uniti ai parametri di route per impostazione predefinita, escludendo i file caricati; per le regole sui file, unisci $request->file() ai dati manualmente, oppure chiama Validator::make manualmente.
• current_password dipende dalla guard di autenticazione; exists/unique dipendono dalla connessione al database e dal query builder; queste regole non sono disponibili quando i componenti corrispondenti non sono integrati.

Di seguito elenco di tutte le regole di validazione disponibili e i loro scopi:

Boolean

String

Numeric

Array

Date

File

Database

Utility

accepted

Il campo deve essere "yes", "on", 1, "1", true o "true". Utilizzato comunemente per scenari come la verifica dell'accettazione dei termini di servizio da parte dell'utente.

accepted_if:anotherfield,value,...

Quando un altro campo è uguale al valore specificato, il campo deve essere "yes", "on", 1, "1", true o "true". Utilizzato comunemente per scenari di accettazione condizionale.

active_url

Il campo deve avere un record A o AAAA valido. Questa regola utilizza prima parse_url per estrarre l'hostname dell'URL, poi valida con dns_get_record.

after:date

Il campo deve essere un valore successivo alla data indicata. La data viene passata a strtotime per convertirla in un DateTime valido:

use support\validation\Validator;

Validator::make($data, [
    'start_date' => 'required|date|after:tomorrow',
])->validate();

È possibile passare anche il nome di un altro campo per il confronto:

Validator::make($data, [
    'finish_date' => 'required|date|after:start_date',
])->validate();

È possibile utilizzare il builder fluente della regola date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->after(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

afterToday e todayOrAfter esprimono comodamente "deve essere dopo oggi" o "deve essere oggi o successivo":

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterToday(),
    ],
])->validate();

after_or_equal:date

Il campo deve essere nella data indicata o successiva. Vedi after per maggiori dettagli.

È possibile utilizzare il builder fluente della regola date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterOrEqual(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

anyOf

Rule::anyOf consente di specificare "soddisfare uno qualsiasi dei set di regole". Ad esempio, la seguente regola significa che username deve essere un indirizzo email oppure una stringa alfanumerica/underscore/trattino di almeno 6 caratteri:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'username' => [
        'required',
        Rule::anyOf([
            ['string', 'email'],
            ['string', 'alpha_dash', 'min:6'],
        ]),
    ],
])->validate();

alpha

Il campo deve essere costituito da lettere Unicode (\p{L} e \p{M}).

Per consentire solo ASCII (a-z, A-Z), aggiungere l'opzione ascii:

Validator::make($data, [
    'username' => 'alpha:ascii',
])->validate();

alpha_dash

Il campo può contenere solo lettere e numeri Unicode (\p{L}, \p{M}, \p{N}), più il trattino ASCII (-) e l'underscore (_).

Per consentire solo ASCII (a-z, A-Z, 0-9), aggiungere l'opzione ascii:

Validator::make($data, [
    'username' => 'alpha_dash:ascii',
])->validate();

alpha_num

Il campo può contenere solo lettere e numeri Unicode (\p{L}, \p{M}, \p{N}).

Per consentire solo ASCII (a-z, A-Z, 0-9), aggiungere l'opzione ascii:

Validator::make($data, [
    'username' => 'alpha_num:ascii',
])->validate();

array

Il campo deve essere un array PHP.

Quando la regola array ha parametri aggiuntivi, le chiavi dell'array di input devono essere nell'elenco dei parametri. Nell'esempio, la chiave admin non è nell'elenco consentito, quindi non è valida:

use support\validation\Validator;

$input = [
    'user' => [
        'name' => 'Taylor Otwell',
        'username' => 'taylorotwell',
        'admin' => true,
    ],
];

Validator::make($input, [
    'user' => 'array:name,username',
])->validate();

Si consiglia di definire esplicitamente le chiavi dell'array consentite nei progetti reali.

ascii

Il campo può contenere solo caratteri ASCII a 7 bit.

bail

Interrompere la validazione delle regole successive per il campo quando la prima regola fallisce.

Questa regola influisce solo sul campo corrente. Per "interrompere al primo fallimento globalmente", utilizzare direttamente il validatore di Illuminate e chiamare stopOnFirstFailure().

before:date

Il campo deve essere precedente alla data indicata. La data viene passata a strtotime per convertirla in un DateTime valido. Come after, è possibile passare il nome di un altro campo per il confronto.

È possibile utilizzare il builder fluente della regola date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->before(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

beforeToday e todayOrBefore esprimono comodamente "deve essere prima di oggi" o "deve essere oggi o precedente":

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeToday(),
    ],
])->validate();

before_or_equal:date

Il campo deve essere nella data indicata o precedente. La data viene passata a strtotime per convertirla in un DateTime valido. Come after, è possibile passare il nome di un altro campo per il confronto.

È possibile utilizzare il builder fluente della regola date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeOrEqual(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

between:min,max

La dimensione del campo deve essere compresa tra min e max (inclusi). La valutazione per stringhe, numeri, array e file è la stessa di size.

boolean

Il campo deve essere convertibile in boolean. Gli input accettabili includono true, false, 1, 0, "1", "0".

Utilizzare il parametro strict per consentire solo true o false:

Validator::make($data, [
    'foo' => 'boolean:strict',
])->validate();

confirmed

Il campo deve avere un campo corrispondente {field}_confirmation. Ad esempio, quando il campo è password, è richiesto password_confirmation.

È possibile specificare anche un nome personalizzato per il campo di conferma, ad es. confirmed:repeat_username richiede che repeat_username corrisponda al campo corrente.

contains:foo,bar,...

Il campo deve essere un array e deve contenere tutti i valori dei parametri indicati. Questa regola è comunemente utilizzata per la validazione degli array; è possibile usare Rule::contains per costruirla:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::contains(['admin', 'editor']),
    ],
])->validate();

doesnt_contain:foo,bar,...

Il campo deve essere un array e non deve contenere nessuno dei valori dei parametri indicati. È possibile usare Rule::doesntContain per costruirla:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::doesntContain(['admin', 'editor']),
    ],
])->validate();

current_password

Il campo deve corrispondere alla password dell'utente autenticato corrente. È possibile specificare la guard di autenticazione come primo parametro:

Validator::make($data, [
    'password' => 'current_password:api',
])->validate();

[!WARNING]
Questa regola dipende dal componente auth e dalla configurazione della guard; non utilizzare quando l'autenticazione non è integrata.

date

Il campo deve essere una data valida (non relativa) riconoscibile da strtotime.

date_equals:date

Il campo deve essere uguale alla data indicata. La data viene passata a strtotime per convertirla in un DateTime valido.

date_format:format,...

Il campo deve corrispondere a uno dei formati indicati. Utilizzare date oppure date_format. Questa regola supporta tutti i formati DateTime di PHP.

È possibile utilizzare il builder fluente della regola date:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->format('Y-m-d'),
    ],
])->validate();

decimal:min,max

Il campo deve essere numerico con il numero di decimali richiesto:

Validator::make($data, [
    'price' => 'decimal:2',
])->validate();

Validator::make($data, [
    'price' => 'decimal:2,4',
])->validate();

declined

Il campo deve essere "no", "off", 0, "0", false o "false".

declined_if:anotherfield,value,...

Quando un altro campo è uguale al valore specificato, il campo deve essere "no", "off", 0, "0", false o "false".

different:field

Il campo deve essere diverso da field.

digits:value

Il campo deve essere un intero con lunghezza value.

digits_between:min,max

Il campo deve essere un intero con lunghezza compresa tra min e max.

dimensions

Il campo deve essere un'immagine e soddisfare i vincoli di dimensione:

Validator::make($data, [
    'avatar' => 'dimensions:min_width=100,min_height=200',
])->validate();

Vincoli disponibili: min_width, max_width, min_height, max_height, width, height, ratio.

ratio è il rapporto d'aspetto; può essere espresso come frazione o float:

Validator::make($data, [
    'avatar' => 'dimensions:ratio=3/2',
])->validate();

Questa regola ha molti parametri; si consiglia di usare Rule::dimensions per costruirla:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'avatar' => [
        'required',
        Rule::dimensions()
            ->maxWidth(1000)
            ->maxHeight(500)
            ->ratio(3 / 2),
    ],
])->validate();

distinct

Durante la validazione degli array, i valori del campo non devono essere duplicati:

Validator::make($data, [
    'foo.*.id' => 'distinct',
])->validate();

Utilizza il confronto loose per impostazione predefinita. Aggiungere strict per il confronto stretto:

Validator::make($data, [
    'foo.*.id' => 'distinct:strict',
])->validate();

Aggiungere ignore_case per ignorare le differenze di maiuscole/minuscole:

Validator::make($data, [
    'foo.*.id' => 'distinct:ignore_case',
])->validate();

doesnt_start_with:foo,bar,...

Il campo non deve iniziare con nessuno dei valori specificati.

doesnt_end_with:foo,bar,...

Il campo non deve terminare con nessuno dei valori specificati.

email

Il campo deve essere un indirizzo email valido. Questa regola dipende da egulias/email-validator, utilizza RFCValidation per impostazione predefinita e può usare altri metodi di validazione:

Validator::make($data, [
    'email' => 'email:rfc,dns',
])->validate();

Metodi di validazione disponibili:

È possibile utilizzare il builder fluente delle regole:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::email()
            ->rfcCompliant(strict: false)
            ->validateMxRecord()
            ->preventSpoofing(),
    ],
])->validate();

[!WARNING]
dns e spoof richiedono l'estensione PHP intl.

encoding:encoding_type

Il campo deve corrispondere alla codifica dei caratteri specificata. Questa regola utilizza mb_check_encoding per rilevare la codifica di file o stringa. Può essere usata con il builder della regola file:

use Illuminate\Validation\Rules\File;
use support\validation\Validator;

Validator::make($data, [
    'attachment' => [
        'required',
        File::types(['csv'])->encoding('utf-8'),
    ],
])->validate();

ends_with:foo,bar,...

Il campo deve terminare con uno dei valori specificati.

enum

Enum è una regola basata su classe per validare che il valore del campo sia un valore enum valido. Passare il nome della classe enum durante la costruzione. Per valori primitivi, utilizzare Backed Enum:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [Rule::enum(ServerStatus::class)],
])->validate();

Utilizzare only/except per limitare i valori enum:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->only([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->except([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Utilizzare when per restrizioni condizionali:

use app\Enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)->when(
            $isAdmin,
            fn ($rule) => $rule->only(ServerStatus::Active),
            fn ($rule) => $rule->only(ServerStatus::Pending),
        ),
    ],
])->validate();

exclude

Il campo sarà escluso dai dati restituiti da validate/validated.

exclude_if:anotherfield,value

Quando anotherfield è uguale a value, il campo sarà escluso dai dati restituiti da validate/validated.

Per condizioni complesse, utilizzare Rule::excludeIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::excludeIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::excludeIf(fn () => $isAdmin),
])->validate();

exclude_unless:anotherfield,value

A meno che anotherfield non sia uguale a value, il campo sarà escluso dai dati restituiti da validate/validated. Se value è null (es. exclude_unless:name,null), il campo viene mantenuto solo quando il campo di confronto è null o assente.

exclude_with:anotherfield

Quando anotherfield esiste, il campo sarà escluso dai dati restituiti da validate/validated.

exclude_without:anotherfield

Quando anotherfield non esiste, il campo sarà escluso dai dati restituiti da validate/validated.

exists:table,column

Il campo deve esistere nella tabella del database specificata.

Utilizzo base della regola Exists

Validator::make($data, [
    'state' => 'exists:states',
])->validate();

Quando column non è specificato, viene utilizzato per impostazione predefinita il nome del campo. Quindi questo esempio valida se la colonna state esiste nella tabella states.

Specificare un nome di colonna personalizzato

Aggiungere il nome della colonna dopo il nome della tabella:

Validator::make($data, [
    'state' => 'exists:states,abbreviation',
])->validate();

Per specificare una connessione al database, anteporre il nome della connessione al nome della tabella:

Validator::make($data, [
    'email' => 'exists:connection.staff,email',
])->validate();

È possibile passare anche un nome di classe modello; il framework risolverà il nome della tabella:

Validator::make($data, [
    'user_id' => 'exists:app\model\User,id',
])->validate();

Per condizioni di query personalizzate, utilizzare il builder Rule:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::exists('staff')->where(function (Builder $query) {
            $query->where('account_id', 1);
        }),
    ],
])->validate();

È possibile specificare direttamente il nome della colonna in Rule::exists:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'state' => [Rule::exists('states', 'abbreviation')],
])->validate();

Per validare che un insieme di valori esista, combinare con la regola array:

Validator::make($data, [
    'states' => ['array', Rule::exists('states', 'abbreviation')],
])->validate();

Quando sono presenti sia array che exists, una singola query valida tutti i valori.

extensions:foo,bar,...

Valida che l'estensione del file caricato sia nell'elenco consentito:

Validator::make($data, [
    'photo' => ['required', 'extensions:jpg,png'],
])->validate();

[!WARNING]
Non fare affidamento solo sull'estensione per la validazione del tipo di file; utilizzare insieme a mimes o mimetypes.

file

Il campo deve essere un file caricato con successo.

filled

Quando il campo esiste, il suo valore non deve essere vuoto.

gt:field

Il campo deve essere maggiore del field o del value indicato. Entrambi i campi devono avere lo stesso tipo. La valutazione per stringhe, numeri, array e file è la stessa di size.

gte:field

Il campo deve essere maggiore o uguale al field o al value indicato. Entrambi i campi devono avere lo stesso tipo. La valutazione per stringhe, numeri, array e file è la stessa di size.

hex_color

Il campo deve essere un valore colore esadecimale valido.

image

Il campo deve essere un'immagine (jpg, jpeg, png, bmp, gif o webp).

[!WARNING]
SVG non è consentito per impostazione predefinita a causa del rischio XSS. Per consentirlo, aggiungere allow_svg: image:allow_svg.

in:foo,bar,...

Il campo deve essere nell'elenco dei valori indicati. È possibile usare Rule::in per costruirlo:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'zones' => [
        'required',
        Rule::in(['first-zone', 'second-zone']),
    ],
])->validate();

Quando combinato con la regola array, ogni valore nell'array di input deve essere nell'elenco in:

use support\validation\Rule;
use support\validation\Validator;

$input = [
    'airports' => ['NYC', 'LAS'],
];

Validator::make($input, [
    'airports' => [
        'required',
        'array',
    ],
    'airports.*' => Rule::in(['NYC', 'LIT']),
])->validate();

in_array:anotherfield.*

Il campo deve esistere nell'elenco dei valori di anotherfield.

in_array_keys:value.*

Il campo deve essere un array e deve contenere almeno uno dei valori indicati come chiave:

Validator::make($data, [
    'config' => 'array|in_array_keys:timezone',
])->validate();

integer

Il campo deve essere un intero.

Utilizzare il parametro strict per richiedere che il tipo del campo sia integer; gli interi stringa non saranno validi:

Validator::make($data, [
    'age' => 'integer:strict',
])->validate();

[!WARNING]
Questa regola valida solo se supera FILTER_VALIDATE_INT di PHP; per tipi numerici stretti, utilizzare insieme a numeric.

ip

Il campo deve essere un indirizzo IP valido.

ipv4

Il campo deve essere un indirizzo IPv4 valido.

ipv6

Il campo deve essere un indirizzo IPv6 valido.

json

Il campo deve essere una stringa JSON valida.

lt:field

Il campo deve essere minore del field indicato. Entrambi i campi devono avere lo stesso tipo. La valutazione per stringhe, numeri, array e file è la stessa di size.

lte:field

Il campo deve essere minore o uguale al field indicato. Entrambi i campi devono avere lo stesso tipo. La valutazione per stringhe, numeri, array e file è la stessa di size.

lowercase

Il campo deve essere in minuscolo.

list

Il campo deve essere un array lista. Le chiavi dell'array lista devono essere numeri consecutivi da 0 a count($array) - 1.

mac_address

Il campo deve essere un indirizzo MAC valido.

max:value

Il campo deve essere minore o uguale a value. La valutazione per stringhe, numeri, array e file è la stessa di size.

max_digits:value

Il campo deve essere un intero con lunghezza non superiore a value.

mimetypes:text/plain,...

Valida che il tipo MIME del file sia nell'elenco:

Validator::make($data, [
    'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime',
])->validate();

Il tipo MIME viene determinato leggendo il contenuto del file e può differire dal MIME fornito dal client.

mimes:foo,bar,...

Valida che il tipo MIME del file corrisponda all'estensione indicata:

Validator::make($data, [
    'photo' => 'mimes:jpg,bmp,png',
])->validate();

Sebbene i parametri siano estensioni, questa regola legge il contenuto del file per determinare il MIME. Mappatura estensione-MIME:

https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

Tipi MIME e estensioni

Questa regola non valida che "estensione del file" corrisponda a "MIME effettivo". Ad esempio, mimes:png considera valido photo.txt con contenuto PNG. Per validare l'estensione, utilizzare extensions.

min:value

Il campo deve essere maggiore o uguale a value. La valutazione per stringhe, numeri, array e file è la stessa di size.

min_digits:value

Il campo deve essere un intero con lunghezza non inferiore a value.

multiple_of:value

Il campo deve essere un multiplo di value.

missing

Il campo non deve esistere nei dati di input.

missing_if:anotherfield,value,...

Quando anotherfield è uguale a qualsiasi value, il campo non deve esistere.

missing_unless:anotherfield,value

A meno che anotherfield non sia uguale a qualsiasi value, il campo non deve esistere.

missing_with:foo,bar,...

Quando uno qualsiasi dei campi specificati esiste, il campo non deve esistere.

missing_with_all:foo,bar,...

Quando tutti i campi specificati esistono, il campo non deve esistere.

not_in:foo,bar,...

Il campo non deve essere nell'elenco dei valori indicati. È possibile usare Rule::notIn per costruirlo:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'toppings' => [
        'required',
        Rule::notIn(['sprinkles', 'cherries']),
    ],
])->validate();

not_regex:pattern

Il campo non deve corrispondere all'espressione regolare indicata.

Questa regola utilizza preg_match di PHP. L'espressione regolare deve avere delimitatori, es. 'email' => 'not_regex:/^.+$/i'.

[!WARNING]
Quando si usano regex/not_regex, se l'espressione regolare contiene |, usare la forma array per evitare conflitti con il separatore |.

nullable

Il campo può essere null.

numeric

Il campo deve essere numeric.

Utilizzare il parametro strict per consentire solo tipi integer o float; le stringhe numeriche non saranno valide:

Validator::make($data, [
    'amount' => 'numeric:strict',
])->validate();

present

Il campo deve esistere nei dati di input.

present_if:anotherfield,value,...

Quando anotherfield è uguale a qualsiasi value, il campo deve esistere.

present_unless:anotherfield,value

A meno che anotherfield non sia uguale a qualsiasi value, il campo deve esistere.

present_with:foo,bar,...

Quando uno qualsiasi dei campi specificati esiste, il campo deve esistere.

present_with_all:foo,bar,...

Quando tutti i campi specificati esistono, il campo deve esistere.

prohibited

Il campo deve essere assente o vuoto. "Vuoto" significa:

prohibited_if:anotherfield,value,...

Quando anotherfield è uguale a qualsiasi value, il campo deve essere assente o vuoto. "Vuoto" significa:

Per condizioni complesse, utilizzare Rule::prohibitedIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::prohibitedIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::prohibitedIf(fn () => $isAdmin),
])->validate();

prohibited_if_accepted:anotherfield,...

Quando anotherfield è "yes", "on", 1, "1", true o "true", il campo deve essere assente o vuoto.

prohibited_if_declined:anotherfield,...

Quando anotherfield è "no", "off", 0, "0", false o "false", il campo deve essere assente o vuoto.

prohibited_unless:anotherfield,value,...

A meno che anotherfield non sia uguale a qualsiasi value, il campo deve essere assente o vuoto. "Vuoto" significa:

prohibits:anotherfield,...

Quando il campo esiste e non è vuoto, tutti i campi in anotherfield devono essere assenti o vuoti. "Vuoto" significa:

regex:pattern

Il campo deve corrispondere all'espressione regolare indicata.

Questa regola utilizza preg_match di PHP. L'espressione regolare deve avere delimitatori, es. 'email' => 'regex:/^.+@.+$/i'.

[!WARNING]
Quando si usano regex/not_regex, se l'espressione regolare contiene |, usare la forma array per evitare conflitti con il separatore |.

required

Il campo deve esistere e non essere vuoto. "Vuoto" significa:

required_if:anotherfield,value,...

Quando anotherfield è uguale a qualsiasi value, il campo deve esistere e non essere vuoto.

Per condizioni complesse, utilizzare Rule::requiredIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::requiredIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::requiredIf(fn () => $isAdmin),
])->validate();

required_if_accepted:anotherfield,...

Quando anotherfield è "yes", "on", 1, "1", true o "true", il campo deve esistere e non essere vuoto.

required_if_declined:anotherfield,...

Quando anotherfield è "no", "off", 0, "0", false o "false", il campo deve esistere e non essere vuoto.

required_unless:anotherfield,value,...

A meno che anotherfield non sia uguale a qualsiasi value, il campo deve esistere e non essere vuoto. Se value è null (es. required_unless:name,null), il campo può essere vuoto solo quando il campo di confronto è null o assente.

required_with:foo,bar,...

Quando uno qualsiasi dei campi specificati esiste e non è vuoto, il campo deve esistere e non essere vuoto.

required_with_all:foo,bar,...

Quando tutti i campi specificati esistono e non sono vuoti, il campo deve esistere e non essere vuoto.

required_without:foo,bar,...

Quando uno qualsiasi dei campi specificati è vuoto o assente, il campo deve esistere e non essere vuoto.

required_without_all:foo,bar,...

Quando tutti i campi specificati sono vuoti o assenti, il campo deve esistere e non essere vuoto.

required_array_keys:foo,bar,...

Il campo deve essere un array e deve contenere almeno le chiavi specificate.

sometimes

Applicare le regole di validazione successive solo quando il campo esiste. Utilizzato comunemente per campi "opzionali ma devono essere validi se presenti":

Validator::make($data, [
    'nickname' => 'sometimes|string|max:20',
])->validate();

same:field

Il campo deve essere uguale a field.

size:value

La dimensione del campo deve essere uguale al value indicato. Per le stringhe: conteggio caratteri; per i numeri: intero specificato (usare con numeric o integer); per gli array: conteggio elementi; per i file: dimensione in KB. Esempio:

Validator::make($data, [
    'title' => 'size:12',
    'seats' => 'integer|size:10',
    'tags' => 'array|size:5',
    'image' => 'file|size:512',
])->validate();

starts_with:foo,bar,...

Il campo deve iniziare con uno dei valori specificati.

string

Il campo deve essere una stringa. Per consentire null, utilizzare con nullable.

timezone

Il campo deve essere un identificatore di timezone valido (da DateTimeZone::listIdentifiers). È possibile passare i parametri supportati da quel metodo:

Validator::make($data, [
    'timezone' => 'required|timezone:all',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:Africa',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:per_country,US',
])->validate();

unique:table,column

Il campo deve essere univoco nella tabella specificata.

Specificare nome tabella/colonna personalizzato:

È possibile specificare direttamente il nome della classe modello:

Validator::make($data, [
    'email' => 'unique:app\model\User,email_address',
])->validate();

È possibile specificare il nome della colonna (per impostazione predefinita viene usato il nome del campo se non specificato):

Validator::make($data, [
    'email' => 'unique:users,email_address',
])->validate();

Specificare connessione al database:

Validator::make($data, [
    'email' => 'unique:connection.users,email_address',
])->validate();

Ignorare ID specificato:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::unique('users')->ignore($user->id),
    ],
])->validate();

[!WARNING]
ignore non dovrebbe ricevere input dall'utente; utilizzare solo ID univoci generati dal sistema (ID auto-increment o UUID del modello), altrimenti potrebbe esistere rischio di SQL injection.

È possibile passare anche un'istanza del modello:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user),
    ],
])->validate();

Se la chiave primaria non è id, specificare il nome della chiave primaria:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user->id, 'user_id'),
    ],
])->validate();

Per impostazione predefinita utilizza il nome del campo come colonna univoca; è possibile specificare anche il nome della colonna:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users', 'email_address')->ignore($user->id),
    ],
])->validate();

Aggiungere condizioni extra:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->where(
            fn (Builder $query) => $query->where('account_id', 1)
        ),
    ],
])->validate();

Ignorare record soft-deleted:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed()],
])->validate();

Se la colonna di soft delete non è deleted_at:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed('was_deleted_at')],
])->validate();

uppercase

Il campo deve essere in maiuscolo.

url

Il campo deve essere un URL valido.

È possibile specificare i protocolli consentiti:

Validator::make($data, [
    'url' => 'url:http,https',
    'game' => 'url:minecraft,steam',
])->validate();

ulid

Il campo deve essere un ULID valido.

uuid

Il campo deve essere un UUID RFC 9562 valido (versione 1, 3, 4, 5, 6, 7 o 8).

È possibile specificare la versione:

Validator::make($data, [
    'uuid' => 'uuid:4',
])->validate();

Validatore top-think/think-validate

Descrizione

Validatore ufficiale ThinkPHP

URL del progetto

https://github.com/top-think/think-validate

Installazione

composer require topthink/think-validate

Avvio rapido

Creare app/index/validate/User.php

<?php 
namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule =   [
        'name'  => 'require|max:25',
        'age'   => 'number|between:1,120',
        'email' => 'email',    
    ];

    protected $message  =   [
        'name.require' => 'Il nome è obbligatorio',
        'name.max'     => 'Il nome non può superare i 25 caratteri',
        'age.number'   => 'L\'età deve essere un numero',
        'age.between'  => 'L\'età deve essere compresa tra 1 e 120',
        'email'        => 'Formato email non valido',    
    ];

}

Utilizzo

$data = [
    'name'  => 'thinkphp',
    'email' => 'thinkphp@qq.com',
];

$validate = new \app\index\validate\User;

if (!$validate->check($data)) {
    var_dump($validate->getError());
}

Nota
webman non supporta il metodo Validate::rule() di think-validate

Validatore workerman/validation

Descrizione

Questo progetto è una versione localizzata di https://github.com/Respect/Validation

URL del progetto

https://github.com/walkor/validation

Installazione

composer require workerman/validation

Avvio rapido

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use support\Db;

class IndexController
{
    public function index(Request $request)
    {
        $data = v::input($request->post(), [
            'nickname' => v::length(1, 64)->setName('Nickname'),
            'username' => v::alnum()->length(5, 64)->setName('Username'),
            'password' => v::length(5, 64)->setName('Password')
        ]);
        Db::table('user')->insert($data);
        return json(['code' => 0, 'msg' => 'ok']);
    }
}  

Accesso tramite jQuery
 
 js  $.ajax({      url: 'http://127.0.0.1:8787',      type: "post",      dataType: 'json',      data: {nickname: 'Tom', username: 'tom cat', password: '123456'}  });  

Risultato:

{"code":500,"msg":"Nome utente può contenere solo lettere (a-z) e numeri (0-9)"}

Spiegazione:

v::input(array $input, array $rules) valida e raccoglie i dati. Se la validazione fallisce, lancia Respect\Validation\Exceptions\ValidationException; in caso di successo restituisce i dati validati (array).

Se il codice di business non cattura l'eccezione di validazione, il framework webman la catturerà e restituirà JSON (come {"code":500, "msg":"xxx"}) o una pagina di eccezione normale in base agli header HTTP. Se il formato di risposta non soddisfa le tue esigenze, puoi catturare ValidationException e restituire dati personalizzati, come nell'esempio seguente:

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use Respect\Validation\Exceptions\ValidationException;

class IndexController
{
    public function index(Request $request)
    {
        try {
            $data = v::input($request->post(), [
                'username' => v::alnum()->length(5, 64)->setName('Username'),
                'password' => v::length(5, 64)->setName('Password')
            ]);
        } catch (ValidationException $e) {
            return json(['code' => 500, 'msg' => $e->getMessage()]);
        }
        return json(['code' => 0, 'msg' => 'ok', 'data' => $data]);
    }
}

Guida al validatore

use Respect\Validation\Validator as v;

// Validazione singola regola
$number = 123;
v::numericVal()->validate($number); // true

// Validazione concatenata
$usernameValidator = v::alnum()->noWhitespace()->length(1, 15);
$usernameValidator->validate('alganet'); // true

// Ottenere la prima causa di fallimento della validazione
try {
    $usernameValidator->setName('Username')->check('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getMessage(); // Nome utente può contenere solo lettere (a-z) e numeri (0-9)
}

// Ottenere tutte le cause di fallimento della validazione
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getFullMessage();
    // Stamperà
    // -  Username must satisfy the following rules
    //     - Username may only contain letters (a-z) and numbers (0-9)
    //     - Username must not contain whitespace

    var_export($exception->getMessages());
    // Stamperà
    // array (
    //   'alnum' => 'Username may only contain letters (a-z) and numbers (0-9)',
    //   'noWhitespace' => 'Username must not contain whitespace',
    // )
}

// Messaggi di errore personalizzati
try {
    $usernameValidator->setName('Nome utente')->assert('alg  anet');
} catch (ValidationException $exception) {
    var_export($exception->getMessages([
        'alnum' => 'Il nome utente può contenere solo lettere e numeri',
        'noWhitespace' => 'Il nome utente non può contenere spazi',
        'length' => 'La lunghezza è valida. Questo non sarà visualizzato'
    ]);
    // Stampa 
    // array(
    //    'alnum' => 'Il nome utente può contenere solo lettere e numeri',
    //    'noWhitespace' => 'Il nome utente non può contenere spazi'
    // )
}

// Validare oggetto
$user = new stdClass;
$user->name = 'Alexandre';
$user->birthdate = '1987-07-01';
$userValidator = v::attribute('name', v::stringType()->length(1, 32))
                ->attribute('birthdate', v::date()->minAge(18));
$userValidator->validate($user); // true

// Validare array
$data = [
    'parentKey' => [
        'field1' => 'value1',
        'field2' => 'value2'
        'field3' => true,
    ]
];
v::key(
    'parentKey',
    v::key('field1', v::stringType())
        ->key('field2', v::stringType())
        ->key('field3', v::boolType())
    )
    ->assert($data); // Può anche usare check() o validate()

// Validazione opzionale
v::alpha()->validate(''); // false 
v::alpha()->validate(null); // false 
v::optional(v::alpha())->validate(''); // true
v::optional(v::alpha())->validate(null); // true

// Regola di negazione
v::not(v::intVal())->validate(10); // false

Differenza tra i metodi del validatore validate() check() assert()

validate() restituisce boolean, non lancia eccezione

check() lancia eccezione in caso di fallimento della validazione; ottieni la prima causa di fallimento tramite $exception->getMessage()

assert() lancia eccezione in caso di fallimento della validazione; ottieni tutte le cause di fallimento tramite $exception->getFullMessage()

Regole di validazione comuni

Alnum() Solo lettere e numeri

Alpha() Solo lettere

ArrayType() Tipo array

Between(mixed $minimum, mixed $maximum) Valida che l'input sia tra due valori.

BoolType() Valida tipo booleano

Contains(mixed $expectedValue) Valida che l'input contenga un certo valore

ContainsAny(array $needles) Valida che l'input contenga almeno un valore definito

Digit() Valida che l'input contenga solo cifre

Domain() Valida nome dominio valido

Email() Valida indirizzo email valido

Extension(string $extension) Valida estensione file

FloatType() Valida tipo float

IntType() Valida tipo intero

Ip() Valida indirizzo IP

Json() Valida dati JSON

Length(int $min, int $max) Valida che la lunghezza sia nell'intervallo

LessThan(mixed $compareTo) Valida che la lunghezza sia minore del valore specificato

Lowercase() Valida minuscolo

MacAddress() Valida indirizzo MAC

NotEmpty() Valida non vuoto

NullType() Valida null

Number() Valida numero

ObjectType() Valida tipo oggetto

StringType() Valida tipo stringa

Url() Valida URL

Vedi https://respect-validation.readthedocs.io/en/2.0/list-of-rules/ per ulteriori regole di validazione.

Altro

Visita https://respect-validation.readthedocs.io/en/2.0/