Valitron Documentation

Valitron supports dot notation to access nested array members. You can use an asterisk (*) to apply a rule to every element in an array or every element within a nested array.

// Validate threshold in nested settings array
$v = new Valitron\Validator(array('settings' => array(
    array('threshold' => 50),
    array('threshold' => 90)
)));
$v->rule('max', 'settings.*.threshold', 100);

// Validate all members of a numeric array
$v = new Valitron\Validator(array('values' => array(50, 90)));
$v->rule('max', 'values.*', 100);

// Access nested values using dot notation
$v = new Valitron\Validator(array('user' => array('first_name' => 'Steve', 'last_name' => 'Smith', 'username' => 'Batman123')));
$v->rule('alpha', 'user.first_name')->rule('alpha', 'user.last_name')->rule('alphaNum', 'user.username');

Valitron allows you to conditionally require fields based on the presence of other fields using requiredWith and requiredWithout within the rules() method.

// this rule set would work for either data set...
$data = ['email' => 'test@test.com', 'password' => 'mypassword'];
// or...
$data = ['token' => 'jashdjahs83rufh89y38h38h'];

$v = new Valitron\Validator($data);
$v->rules([
    'requiredWithout' => [
        ['token', ['email', 'password'], true]
    ],
    'requiredWith' => [
        ['password', ['email']]
    ],
    'email' => [
        ['email']
    ],
    'optional' => [
        ['email']
    ]
]);
$v->validate();

To use Valitron, instantiate Valitron\Validator with your data array, define rules using rule(), and call validate(). If validation fails, errors() returns an array of error messages.

$v = new Valitron\Validator(array('name' => 'Chester Tester'));
$v->rule('required', 'name');
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

Valitron is a standalone validation library with no dependencies. You can install it using Composer.

curl -s http://getcomposer.org/installer | php
php composer.phar require vlucas/valitron

To use Valitron, instantiate the Valitron\Validator class. You can pass the data to be validated, an optional array of allowed fields to filter the input, and optional language settings.

If you provide a $fields array, Valitron will only validate the intersection of the provided $data and the $fields keys. This is useful for sanitizing $_POST or $_GET data.

Constructor Parameters

• $data (array): The input data to validate.
• $fields (array, optional): A list of allowed field names. Only these fields will be processed.
• $lang (string, optional): The language code (e.g., 'en').
• $langDir (string, optional): The directory containing language files.

You can pass an array of field names to a single rule to apply it to multiple fields at once. This is useful for validating $_POST or $_GET data directly.

$v = new Valitron\Validator($_POST);
$v->rule('required', ['name', 'email']);
$v->rule('email', 'email');
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

The arrayHasKeys rule ensures that the field is an array and that it contains all the specified keys. It returns false if the field is not an array, if no keys are specified, or if any required key is missing.

$v->rule('arrayHasKeys', 'address', ['name', 'street', 'city']);

The requiredWith rule ensures a field is required (not null and not an empty string) if any of the specified other fields are present.

You can provide a single field name or an array of field names. If an array is provided, the field is required if ANY of the fields in the array are present.

// Required if 'username' is provided
$v->rule('requiredWith', 'password', 'username');

// Required if 'username' OR 'email' is provided
$v->rule('requiredWith', 'password', ['username', 'email']);

// Alternate syntax using rules()
$v->rules([
    'requiredWith' => [
        ['password', ['username', 'email']]
    ]
]);

You can set the validation language and the directory containing language files globally using the static methods on the Validator class.

use Valitron\Validator as V;

V::langDir(__DIR__.'/validator_lang'); // always set langDir before lang.
V::lang('ar');

The regex rule ensures a field matches a specific regular expression pattern.

Usage: $v->rule('regex', 'fieldname', '/pattern/');

$v->rule('regex', 'username', '/^[a-zA-Z0-9]{5,10}$/');