Implementare da zero un sistema di validazione in PHP (stile Laravel)
Laravel | 14/08/2025 | Gabriele Romanato

Implementare da zero un sistema di validazione in PHP (stile Laravel)

In questo articolo creiamo un validatore minimale ma potente in PHP che usa regole in formato stringa come title => "required|max:255". Supporta dot-notation (user.email), messaggi personalizzati, regole comuni (required, max, min, email, numeric, in, regex, …), comportamenti tipo sometimes/nullable e persino estensioni personalizzate, il tutto senza dipendenze esterne.

Risultato finale


// Esempio d'uso
$input = [
    'title' => 'Hello',
    'email' => 'john@example.com',
    'age'   => '21',
    'user'  => ['name' => 'Jane', 'birthdate' => '2000-01-01'],
];

$rules = [
   'title'        => 'required|string|max:255',
   'email'        => 'required|email',
   'age'          => 'nullable|numeric|min:18|max:120',
   'user.name'    => 'sometimes|required|string|min:2',
   'user.birthdate' => 'date|after:1990-01-01',
];

$messages = [
    'title.required' => 'Il titolo è obbligatorio.',
    'age.min'        => 'Devi avere almeno :min anni.',
];

$validator = new Validator();
if ($validator->validate($input, $rules, $messages)) {
    // dati validi
} else {
    // stampa errori
    print_r($validator->errors());
}

Implementazione

Il seguente codice PHP implementa il validatore con: parsing delle regole, dot-notation, gestione messaggi, regole integrate e un meccanismo per aggiungere regole custom.


class Validator
{
    protected array $errors = [];
    protected static array $customRules = [];       // ['rule' => callable]
    protected static array $customMessages = [];    // ['rule' => 'messaggio di default']

    public function errors(): array
    {
        return $this->errors;
    }

    public function validate(array $data, array $rules, array $messages = []): bool
    {
        $this->errors = [];

        foreach ($rules as $attribute => $ruleDef) {
            $parsed = $this->parseRules($ruleDef);
            $bail = in_array('bail', array_column($parsed, 'name'), true);

            $exists = false;
            $value = $this->getValue($data, $attribute, $exists);

            $hasSometimes = $this->hasRule($parsed, 'sometimes');
            if ($hasSometimes && !$exists) {
                continue; // se non c'è il campo, non validare
            }

            $isNullable = $this->hasRule($parsed, 'nullable');
            if ($isNullable && $exists && $value === null) {
                continue; // null è permesso, skip altre regole
            }

            foreach ($parsed as $r) {
                $name = $r['name'];
                $params = $r['params'];

                if (in_array($name, ['sometimes', 'nullable', 'bail'], true)) {
                    continue;
                }

                $passed = true;
                $message = null;

                // Regole integrate
                switch ($name) {
                    case 'required':
                        $passed = $exists && !$this->isEmpty($value);
                        break;

                    case 'string':
                        $passed = is_string($value);
                        break;

                    case 'array':
                        $passed = is_array($value);
                        break;

                    case 'boolean':
                        $passed = is_bool($value) || $value === 0 || $value === 1 || $value === '0' || $value === '1';
                        break;

                    case 'integer':
                        $passed = filter_var($value, FILTER_VALIDATE_INT) !== false;
                        break;

                    case 'numeric':
                        $passed = is_numeric($value);
                        break;

                    case 'email':
                        $passed = filter_var($value, FILTER_VALIDATE_EMAIL) !== false;
                        break;

                    case 'min':
                        $min = $this->expectParam($attribute, $name, $params, 0);
                        $passed = $this->checkMin($value, $min, $parsed);
                        break;

                    case 'max':
                        $max = $this->expectParam($attribute, $name, $params, 0);
                        $passed = $this->checkMax($value, $max, $parsed);
                        break;

                    case 'between':
                        $min = $this->expectParam($attribute, $name, $params, 0);
                        $max = $this->expectParam($attribute, $name, $params, 1);
                        $passed = $this->checkMin($value, $min, $parsed) && $this->checkMax($value, $max, $parsed);
                        break;

                    case 'in':
                        $passed = in_array((string)$value, array_map('strval', $params), true);
                        break;

                    case 'regex':
                        $pattern = $this->expectParam($attribute, $name, $params, 0);
                        $passed = @preg_match($pattern, (string)$value) === 1;
                        break;

                    case 'date':
                        $passed = $this->parseDate($value) instanceof DateTimeInterface;
                        break;

                    case 'after':
                        $other = $this->expectParam($attribute, $name, $params, 0);
                        $passed = $this->compareDates($data, $attribute, $value, $other, '>');
                        break;

                    case 'before':
                        $other = $this->expectParam($attribute, $name, $params, 0);
                        $passed = $this->compareDates($data, $attribute, $value, $other, '<');
                        break;

                    default:
                        // Regola custom
                        if (isset(self::$customRules[$name])) {
                            $callback = self::$customRules[$name];
                            $result = $callback($attribute, $value, $params, $data);
                            if ($result === true) {
                                $passed = true;
                            } elseif ($result === false) {
                                $passed = false;
                            } elseif (is_string($result)) {
                                $passed = false;
                                $message = $result; // messaggio diretto dalla regola
                            }
                        } else {
                            throw new InvalidArgumentException("Regola sconosciuta: {$name}");
                        }
                }

                if (!$passed) {
                    $this->addError(
                        $attribute,
                        $name,
                        $message ?? $this->makeMessage($attribute, $name, $params, $messages, $value),
                        $params
                    );

                    if ($bail) {
                        break; // interrompi alla prima violazione per questo campo
                    }
                }
            }
        }

        return empty($this->errors);
    }

    /** ------------------------------- Helper: parsing & accesso ------------------------------- */

    protected function parseRules(string|array $ruleDef): array
    {
        if (is_array($ruleDef)) {
            $chunks = $ruleDef;
        } else {
            // Supporta | e : escapati
            $chunks = preg_split('/(?<!)|/', $ruleDef) ?: [];
            $chunks = array_map(fn($c) => str_replace(['|', ':'], ['|', ':'], trim($c)), $chunks);
        }

        $out = [];
        foreach ($chunks as $chunk) {
            if ($chunk === '') continue;
            $parts = preg_split('/(?<!):/', $chunk, 2);
            $name = strtolower(trim($parts[0]));
            $params = [];
            if (isset($parts[1])) {
                $params = array_map('trim', explode(',', $parts[1]));
            }
            $out[] = ['name' => $name, 'params' => $params];
        }
        return $out;
    }

    protected function hasRule(array $parsed, string $rule): bool
    {
        foreach ($parsed as $r) {
            if ($r['name'] === $rule) return true;
        }
        return false;
    }

    protected function getValue(array $data, string $key, ?bool &$exists = null)
    {
        $segments = explode('.', $key);
        $cur = $data;
        foreach ($segments as $seg) {
            if (is_array($cur) && array_key_exists($seg, $cur)) {
                $cur = $cur[$seg];
            } else {
                $exists = false;
                return null;
            }
        }
        $exists = true;
        return $cur;
    }

    protected function isEmpty($value): bool
    {
        if ($value === null) return true;
        if (is_string($value)) return trim($value) === '';
        if (is_array($value)) return count($value) === 0;
        return false;
    }

    /** ------------------------------- Helper: min/max/between ------------------------------- */

    protected function isStringContext(array $parsed): bool
    {
        return $this->hasRule($parsed, 'string');
    }

    protected function isArrayContext(array $parsed): bool
    {
        return $this->hasRule($parsed, 'array');
    }

    protected function isNumericContext(array $parsed): bool
    {
        return $this->hasRule($parsed, 'numeric') || $this->hasRule($parsed, 'integer');
    }

    protected function checkMin($value, $min, array $parsed): bool
    {
        if ($this->isNumericContext($parsed)) {
            return is_numeric($value) && $value + 0 >= (float)$min;
        }
        if ($this->isArrayContext($parsed) && is_array($value)) {
            return count($value) >= (int)$min;
        }
        // default: lunghezza stringa
        return is_string($value) && mb_strlen($value) >= (int)$min;
    }

    protected function checkMax($value, $max, array $parsed): bool
    {
        if ($this->isNumericContext($parsed)) {
            return is_numeric($value) && $value + 0 <= (float)$max;
        }
        if ($this->isArrayContext($parsed) && is_array($value)) {
            return count($value) <= (int)$max;
        }
        // default: lunghezza stringa
        return is_string($value) && mb_strlen($value) <= (int)$max;
    }

    /** ------------------------------- Helper: date & confronti ------------------------------- */

    protected function parseDate($value): ?DateTimeInterface
    {
        if ($value instanceof DateTimeInterface) return $value;
        if (!is_string($value)) return null;

        // prova ISO e fallback a strtotime
        $dt = DateTime::createFromFormat('Y-m-d', $value) ?: DateTime::createFromFormat(DateTime::ATOM, $value);
        if ($dt instanceof DateTimeInterface) return $dt;

        $ts = strtotime($value);
        return $ts ? (new DateTime())->setTimestamp($ts) : null;
    }

    protected function compareDates(array $data, string $attribute, $value, string $other, string $op): bool
    {
        $left = $this->parseDate($value);
        if (!$left) return false;

        if ($other === 'today') {
            $right = (new DateTime('today'));
        } elseif (str_contains($other, '-')) {
            $right = $this->parseDate($other);
        } else {
            $exists = false;
            $otherVal = $this->getValue($data, $other, $exists);
            if (!$exists) return false;
            $right = $this->parseDate($otherVal);
        }

        if (!$right) return false;

        return match ($op) {
            '>' => $left > $right,
            '<' => $left < $right,
            default => false
        };
    }

    /** ------------------------------- Messaggi ------------------------------- */

    protected function addError(string $attribute, string $rule, string $message, array $params): void
    {
        $this->errors[$attribute][$rule][] = $message;
    }

    protected function makeMessage(string $attribute, string $rule, array $params, array $overrides, $value): string
    {
        // Messaggi per-campo
        $key = "{$attribute}.{$rule}";
        if (isset($overrides[$key])) {
            return $this->interpolate($overrides[$key], $attribute, $params, $value);
        }

        // Messaggi predefiniti (per-regola)
        $defaults = $this->defaultMessages();
        if (isset($defaults[$rule])) {
            return $this->interpolate($defaults[$rule], $attribute, $params, $value);
        }

        // Messaggio custom registrato
        if (isset(self::$customMessages[$rule])) {
            return $this->interpolate(self::$customMessages[$rule], $attribute, $params, $value);
        }

        return "Il campo :attribute non è valido.";
    }

    protected function interpolate(string $message, string $attribute, array $params, $value): string
    {
        // parametri comuni
        $repl = [
            ':attribute' => $attribute,
            ':value'     => is_scalar($value) ? (string)$value : '',
        ];

        // parametri posizionali :min, :max, :other ecc.
        $names = [':min', ':max', ':other', ':1', ':2'];
        foreach ($names as $i => $name) {
            if (isset($params[$i])) {
                $repl[$name] = (string)$params[$i];
            }
        }

        return strtr($message, $repl);
    }

    protected function defaultMessages(): array
    {
        return [
            'required' => 'Il campo :attribute è obbligatorio.',
            'string'   => 'Il campo :attribute deve essere una stringa.',
            'array'    => 'Il campo :attribute deve essere un array.',
            'boolean'  => 'Il campo :attribute deve essere booleano.',
            'integer'  => 'Il campo :attribute deve essere un intero.',
            'numeric'  => 'Il campo :attribute deve essere numerico.',
            'email'    => 'Il campo :attribute deve essere un indirizzo email valido.',
            'min'      => 'Il campo :attribute deve essere almeno :min.',
            'max'      => 'Il campo :attribute non può superare :max.',
            'between'  => 'Il campo :attribute deve essere tra :min e :max.',
            'in'       => 'Il campo :attribute deve essere uno dei valori consentiti.',
            'regex'    => 'Il formato di :attribute non è valido.',
            'date'     => 'Il campo :attribute deve essere una data valida.',
            'after'    => 'Il campo :attribute deve essere successivo a :other.',
            'before'   => 'Il campo :attribute deve essere precedente a :other.',
        ];
    }

    protected function expectParam(string $attribute, string $rule, array $params, int $index): string
    {
        if (!isset($params[$index])) {
            throw new InvalidArgumentException("La regola {$rule} per {$attribute} richiede un parametro alla posizione {$index}");
        }
        return $params[$index];
    }

    /** ------------------------------- Estensioni custom ------------------------------- */

    public static function extend(string $name, callable $callback, ?string $defaultMessage = null): void
    {
        self::$customRules[$name] = $callback;
        if ($defaultMessage) {
            self::$customMessages[$name] = $defaultMessage;
        }
    }
}

// ------------------------------- Esempio di estensione: starts_with -------------------------------

Validator::extend('starts_with', function (string $attribute, $value, array $params) {
    $prefix = $params[0] ?? '';
    if (!is_string($value)) return false;
    return str_starts_with($value, $prefix);
}, 'Il campo :attribute deve iniziare con :1.');

// ------------------------------- Esempio di utilizzo -------------------------------

$input = [
    'title' => 'Hello world',
    'email' => 'john@example.com',
    'age'   => '17',
    'slug'  => 'post-1',
];

$rules = [
    'title' => 'required|string|between:3,255|starts_with:Hel',
    'email' => 'required|email',
    'age'   => 'nullable|numeric|min:18', // fallirà
    'slug'  => 'regex:/^[a-z0-9-]+$/',
];

$messages = [
    'slug.regex' => 'Lo slug può contenere solo lettere minuscole, numeri e trattini.',
];

$validator = new Validator();
$ok = $validator->validate($input, $rules, $messages);

if (!$ok) {
    print_r($validator->errors());
}

Dettagli importanti del design

  • Ordine delle regole: viene rispettato; con bail interrompi alla prima violazione per quel campo.
  • Contesto di tipo: min/max operano su numeri se presenti numeric/integer, sulla lunghezza se string, sul conteggio se array.
  • sometimes: valida il campo solo se presente nell’input.
  • nullable: se il valore è null, salta le altre regole del campo.
  • Dot-notation: consente user.email senza dover navigare manualmente l’array.
  • Messaggi: override per campo.regola e template predefiniti con placeholder :attribute, :min, :max, :other, :value.
  • Regole custom: con Validator::extend() aggiungi nuove regole riusabili e un messaggio di default.

Test rapidissimi

Puoi creare dei test veloci in puro PHP per assicurarti che i casi principali siano coperti.


// "happy path"
assert((new Validator())->validate(
    ['name' => 'Anna'], ['name' => 'required|string|min:2']
) === true);

// required fallisce
$v = new Validator();
assert($v->validate(['name' => ''], ['name' => 'required']) === false);
assert(isset($v->errors()['name']['required']));

Estendere il sistema

  • Aggiungi file rules (dimensione, mime) per upload.
  • Supporta wildcard tipo items.*.id (si può iterare ricorsivamente sugli array).
  • Internazionalizzazione dei messaggi tramite file di lingua.
  • Raccogli solo il primo errore per campo quando vuoi errori “compatti”.

Conclusioni

Con poche centinaia di righe abbiamo un validatore flessibile, espressivo e facilmente estendibile, con una sintassi familiare a chi usa Laravel. Puoi inserirlo nei tuoi progetti legacy o micro-servizi dove non vuoi importare l’intero framework ma desideri regole di validazione coerenti e leggibili.

← Precedente
Come rimuovere informazioni e dati non necessari dall'elemento head in WordPress
Successivo →
Introduzione a Pydantic in Python