---
title: "Phalcon Filter"
version: "5.20"
---
> Documentation Index
> Fetch the complete documentation index at: https://docs.phalcon.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Phalcon Filter
:::info[NOTE]
All classes are prefixed with `Phalcon`
:::
## Filter\Exception
Class
Phalcon\Filter\Exception
Exceptions thrown in Phalcon\Filter will use this class
- `\Exception`
- **`Phalcon\Filter\Exception`**
- [`Phalcon\Filter\Exceptions\FilterNotRegistered`](#filterexceptionsfilternotregistered)
## Filter\Exceptions\FilterNotRegistered
Class
- `\Exception`
- [`Phalcon\Filter\Exception`](#filterexception)
- **`Phalcon\Filter\Exceptions\FilterNotRegistered`**
`Phalcon\Filter\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $name );
```
## Filter\Filter
Class
Lazy loads, stores and exposes sanitizer objects
@method int absint(mixed $input)
@method string alnum(mixed $input)
@method string alpha(mixed $input)
@method bool bool(mixed $input)
@method string email(string $input)
@method float float(mixed $input)
@method int int(string $input)
@method false|string ip(string $input, int $filter = 0)
@method string lower(string $input)
@method string lowerfirst(string $input)
@method mixed regex(mixed $input, mixed $pattern, mixed $replace)
@method mixed remove(mixed $input, mixed $replace)
@method mixed replace(mixed $input, mixed $from, mixed $to)
@method string special(string $input)
@method string specialfull(string $input)
@method string string(string $input)
@method string stringlegacy(mixed $input)
@method string striptags(string $input)
@method string trim(string $input)
@method string upper(string $input)
@method string upperFirst(string $input)
@method string|null upperWords(string $input)
@method string|null url(string $input)
@property array $mapper
@property array $services
- **`Phalcon\Filter\Filter`** - implements [`Phalcon\Filter\FilterInterface`](#filterfilterinterface)
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Contracts\Filter\Sanitizer` · `Phalcon\Filter\Exceptions\FilterNotRegistered` · `Phalcon\Filter\Sanitize\AbsInt` · `Phalcon\Filter\Sanitize\Alnum` · `Phalcon\Filter\Sanitize\Alpha` · `Phalcon\Filter\Sanitize\BoolVal` · `Phalcon\Filter\Sanitize\Email` · `Phalcon\Filter\Sanitize\FloatVal` · `Phalcon\Filter\Sanitize\IntVal` · `Phalcon\Filter\Sanitize\Ip` · `Phalcon\Filter\Sanitize\Lower` · `Phalcon\Filter\Sanitize\LowerFirst` · `Phalcon\Filter\Sanitize\Regex` · `Phalcon\Filter\Sanitize\Remove` · `Phalcon\Filter\Sanitize\Replace` · `Phalcon\Filter\Sanitize\Special` · `Phalcon\Filter\Sanitize\SpecialFull` · `Phalcon\Filter\Sanitize\StringVal` · `Phalcon\Filter\Sanitize\StringValLegacy` · `Phalcon\Filter\Sanitize\Striptags` · `Phalcon\Filter\Sanitize\Trim` · `Phalcon\Filter\Sanitize\Upper` · `Phalcon\Filter\Sanitize\UpperFirst` · `Phalcon\Filter\Sanitize\UpperWords` · `Phalcon\Filter\Sanitize\Url`
### Method Summary
Magic call to make the helper objects available as methods.
Filter constructor.
Get a service. If it is not in the mapper array, create a new object,
Returns the default sanitizer name to class map. This is the single
Checks if a service exists in the map array
Sanitizes a value with a specified single or set of sanitizers
Set a new service to the mapper array
Loads the objects in the internal mapper array
### Constants
### Properties
### Methods
__call()
```php
public function __call(
string $name,
array $args
);
```
Magic call to make the helper objects available as methods.
__construct()
```php
public function __construct( array $mapper = [] );
```
Filter constructor.
get()
```php
public function get( string $name ): mixed;
```
Get a service. If it is not in the mapper array, create a new object,
set it and then return it.
getDefaultMapper()
```php
public static function getDefaultMapper(): array;
```
Returns the default sanitizer name to class map. This is the single
source for the built-in sanitizer registry: when adding a sanitizer,
add its `FILTER_*` constant and its entry here.
has()
```php
public function has( string $name ): bool;
```
Checks if a service exists in the map array
sanitize()
```php
public function sanitize(
mixed $value,
mixed $sanitizers,
bool $noRecursive = false
): mixed;
```
Sanitizes a value with a specified single or set of sanitizers
Array policy: when `$value` is an array and `$noRecursive` is `false`
(the default), each element is passed to the sanitizer individually
and an array is returned - recursion is one level deep only. Elements
that are themselves arrays are passed to the sanitizer as-is, which
raises a `TypeError` for sanitizers that type their value parameter
(e.g. `trim`). When `$noRecursive` is `true`, the whole array is
passed to the sanitizer as a single value.
set()
```php
public function set(
string $name,
mixed $service
): void;
```
Set a new service to the mapper array
init()
```php
protected function init( array $mapper ): void;
```
Loads the objects in the internal mapper array
## Filter\FilterFactory
Class
Class FilterFactory
@package Phalcon\Filter
- **`Phalcon\Filter\FilterFactory`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Filter`
### Method Summary
Returns a Locator object with all the helpers defined in anonymous
Returns the available adapters
### Methods
newInstance()
```php
public function newInstance(): FilterInterface;
```
Returns a Locator object with all the helpers defined in anonymous
functions
getServices()
```php
protected function getServices(): array;
```
Returns the available adapters
## Filter\FilterInterface
Interface
Lazy loads, stores and exposes sanitizer objects
- **`Phalcon\Filter\FilterInterface`**
`Phalcon\Contracts\Filter\FilterTypes`
### Method Summary
Sanitizes a value with a specified single or set of sanitizers
### Methods
sanitize()
```php
public function sanitize(
mixed $value,
mixed $sanitizers,
bool $noRecursive = false
): mixed;
```
Sanitizes a value with a specified single or set of sanitizers
Array policy: when `$value` is an array and `$noRecursive` is `false`
(the default), each element is sanitized individually and an array is
returned - recursion is one level deep only. When `$noRecursive` is
`true`, the whole array is passed to the sanitizer as a single value.
## Filter\Sanitize\AbsInt
Class
Sanitizes a value to absolute integer
- **`Phalcon\Filter\Sanitize\AbsInt`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Alnum
Class
Sanitizes a value to an alphanumeric value
- **`Phalcon\Filter\Sanitize\Alnum`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Alpha
Class
Sanitizes a value to an alpha value
- **`Phalcon\Filter\Sanitize\Alpha`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\BoolVal
Class
Sanitizes a value to boolean
- **`Phalcon\Filter\Sanitize\BoolVal`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Email
Class
Sanitizes an email string
- **`Phalcon\Filter\Sanitize\Email`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\FloatVal
Class
Sanitizes a value to float
- **`Phalcon\Filter\Sanitize\FloatVal`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\IntVal
Class
Sanitizes a value to integer
- **`Phalcon\Filter\Sanitize\IntVal`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Ip
Class
Sanitizes a value to an ip address or CIDR range
- **`Phalcon\Filter\Sanitize\Ip`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke(
string $input,
int $filter = 0
): false|string;
```
## Filter\Sanitize\Lower
Class
Sanitizes a value to lowercase
- **`Phalcon\Filter\Sanitize\Lower`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer` · `Phalcon\Traits\Php\MbCaseTrait`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\LowerFirst
Class
Sanitizes a value to lcfirst
- **`Phalcon\Filter\Sanitize\LowerFirst`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Regex
Class
Sanitizes a value performing preg_replace
- **`Phalcon\Filter\Sanitize\Regex`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke(
mixed $input,
mixed $pattern,
mixed $replace
);
```
## Filter\Sanitize\Remove
Class
Sanitizes a value removing parts of a string
- **`Phalcon\Filter\Sanitize\Remove`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke(
mixed $input,
mixed $replace
);
```
## Filter\Sanitize\Replace
Class
Sanitizes a value replacing parts of a string
- **`Phalcon\Filter\Sanitize\Replace`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke(
mixed $input,
mixed $from,
mixed $to
);
```
## Filter\Sanitize\Special
Class
Sanitizes a value special characters
- **`Phalcon\Filter\Sanitize\Special`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\SpecialFull
Class
Sanitizes a value special characters (htmlspecialchars() and ENT_QUOTES)
- **`Phalcon\Filter\Sanitize\SpecialFull`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\StringVal
Class
Sanitizes a value to string
- **`Phalcon\Filter\Sanitize\StringVal`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke(
string $input,
int $flags = 11
): string;
```
## Filter\Sanitize\StringValLegacy
Class
Sanitizes a value to string using `filter_var()`. The filter provides
backwards compatibility with versions prior to v5. For PHP higher or equal to
8.1, the filter will remain the string unchanged. If anything other than a
string is passed, the method will return false
- **`Phalcon\Filter\Sanitize\StringValLegacy`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Striptags
Class
Sanitizes a value striptags
- **`Phalcon\Filter\Sanitize\Striptags`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Trim
Class
Sanitizes a value removing leading and trailing spaces
- **`Phalcon\Filter\Sanitize\Trim`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Upper
Class
Sanitizes a value to uppercase
- **`Phalcon\Filter\Sanitize\Upper`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer` · `Phalcon\Traits\Php\MbCaseTrait`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\UpperFirst
Class
Sanitizes a value to ucfirst
- **`Phalcon\Filter\Sanitize\UpperFirst`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\UpperWords
Class
Sanitizes a value to uppercase the first character of each word
- **`Phalcon\Filter\Sanitize\UpperWords`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer` · `Phalcon\Traits\Php\MbCaseTrait`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Url
Class
Sanitizes a value url
- **`Phalcon\Filter\Sanitize\Url`** - implements [`Phalcon\Contracts\Filter\Sanitizer`](/5.20/api/phalcon_contracts/#contractsfiltersanitizer)
`Phalcon\Contracts\Filter\Sanitizer`
### Method Summary
### Methods
__invoke()
```php
public function __invoke( mixed $input );
```
## Filter\Validation
Class
Allows to validate data using custom or built-in validators
- `\stdClass`
- [`Phalcon\Di\Injectable`](/5.20/api/phalcon_di/#diinjectable)
- **`Phalcon\Filter\Validation`** - implements [`Phalcon\Filter\Validation\ValidationInterface`](#filtervalidationvalidationinterface)
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Di\Di` · `Phalcon\Di\DiInterface` · `Phalcon\Di\Exception` · `Phalcon\Di\Injectable` · `Phalcon\Filter\FilterInterface` · `Phalcon\Filter\Validation\AbstractCombinedFieldsValidator` · `Phalcon\Filter\Validation\Exception` · `Phalcon\Filter\Validation\Exceptions\FilterServiceUnavailable` · `Phalcon\Filter\Validation\Exceptions\InvalidFieldType` · `Phalcon\Filter\Validation\Exceptions\InvalidFilterService` · `Phalcon\Filter\Validation\Exceptions\InvalidValidationData` · `Phalcon\Filter\Validation\Exceptions\InvalidValidator` · `Phalcon\Filter\Validation\Exceptions\InvalidValidatorScope` · `Phalcon\Filter\Validation\Exceptions\NoDataToValidate` · `Phalcon\Filter\Validation\Exceptions\NoValidators` · `Phalcon\Filter\Validation\Exceptions\ValidationEntityNotObject` · `Phalcon\Filter\Validation\ValidationInterface` · `Phalcon\Filter\Validation\ValidatorInterface` · `Phalcon\Messages\MessageInterface` · `Phalcon\Messages\Messages`
### Method Summary
Phalcon\Filter\Validation constructor
Adds a validator to a field
Appends a message to the messages list
Assigns the data to an entity
Verify if validation fails by verifying if there are messages in the current validation
Returns the default message registered for a validator class, or an
Returns the bound entity
Returns all the filters or a specific one
Get label for field
Returns the registered validators
Returns the validators added to the validation
Gets the value to validate in the array/object data source
Gets the value to validate in the array/object data source
Gets the value to validate in the object entity source
Alias of `add` method
Adds the validators to a field
Registers default messages for validators, keyed by validator class
Sets the bound entity
Adds filters to the field
Adds labels for fields
Sets the validator array
Validate a set of data according to a set of rules
Internal validations, if it returns true, then skip the current validator
### Properties
Default messages for validators, keyed by validator class name
Declared without an array initializer on purpose: an initialized static
array makes Zephir emit a zephir_init_static_properties() function that
fails to compile in the single-file build. It is null until first set
and treated as an empty array by the accessors below.
List of validators
Calculated values
### Methods
__construct()
```php
public function __construct( array $validators = [] );
```
Phalcon\Filter\Validation constructor
add()
```php
public function add(
mixed $field,
ValidatorInterface $validator
): static;
```
Adds a validator to a field
appendMessage()
```php
public function appendMessage( MessageInterface $message ): static;
```
Appends a message to the messages list
bind()
```php
public function bind(
mixed $entity,
mixed $data,
array $whitelist = []
): static;
```
Assigns the data to an entity
The entity is used to obtain the validation values
```php
$entity = new Author();
$fields = ['name', 'email', 'imageUrl'];
$validation = new AuthorValidation();
$validation->bind($entity, $_POST, $fields);
$validation->validate();
```
fails()
```php
public function fails(): bool;
```
Verify if validation fails by verifying if there are messages in the current validation
getData()
```php
public function getData(): mixed;
```
getDefaultMessage()
```php
public static function getDefaultMessage( string $validatorClassName ): string;
```
Returns the default message registered for a validator class, or an
empty string when none has been registered.
getEntity()
```php
public function getEntity(): mixed;
```
Returns the bound entity
getFilters()
```php
public function getFilters( string|null $field = null ): mixed|null;
```
Returns all the filters or a specific one
getLabel()
```php
public function getLabel( mixed $field ): string;
```
Get label for field
getMessages()
```php
public function getMessages(): Messages;
```
Returns the registered validators
getValidators()
```php
public function getValidators(): array;
```
Returns the validators added to the validation
getValue()
```php
public function getValue( string $field ): mixed|null;
```
Gets the value to validate in the array/object data source
getValueByData()
```php
public function getValueByData(
mixed $data,
string $field
): mixed|null;
```
Gets the value to validate in the array/object data source
getValueByEntity()
```php
public function getValueByEntity(
mixed $entity,
string $field
): mixed|null;
```
Gets the value to validate in the object entity source
rule()
```php
public function rule(
mixed $field,
ValidatorInterface $validator
): static;
```
Alias of `add` method
@todo remove this
rules()
```php
public function rules(
mixed $field,
array $validators
): static;
```
Adds the validators to a field
setDefaultMessages()
```php
public static function setDefaultMessages( array $messages = [] ): array;
```
Registers default messages for validators, keyed by validator class
name. A registered default is used when a validator does not define its
own message; a message set on the validator instance still wins. Calls
are merged, so defaults can be registered incrementally.
setEntity()
```php
public function setEntity( mixed $entity ): void;
```
Sets the bound entity
setFilters()
```php
public function setFilters(
mixed $field,
mixed $filters
): static;
```
Adds filters to the field
setLabels()
```php
public function setLabels( array $labels ): void;
```
Adds labels for fields
setValidators()
```php
public function setValidators( array $validators ): static;
```
Sets the validator array
validate()
```php
public function validate(
mixed $data = null,
mixed $entity = null,
array $whitelist = []
): Messages|bool;
```
Validate a set of data according to a set of rules
You can use $validation->bind(entity, data, whitelist)->validate()
When you use bind(), the this->data is already set, so you can reuse it here
```php
// using bind() with $whitelist fields
$entity = new Author();
$fields = ['name', 'email', 'imageUrl'];
$validation = new AuthorValidation();
$validation->bind($entity, $_POST, $fields);
$validation->validate();
// directly using validate
$validation = new AuthorValidation();
$validation->validate($_POST, $entity, $fields);
```
preChecking()
```php
protected function preChecking(
mixed $field,
ValidatorInterface $validator
): bool;
```
Internal validations, if it returns true, then skip the current validator
## Filter\Validation\AbstractCombinedFieldsValidator
Abstract
This is a base class for combined fields validators
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\AbstractCombinedFieldsValidator`**
- [`Phalcon\Filter\Validation\Validator\Uniqueness`](#filtervalidationvalidatoruniqueness)
## Filter\Validation\AbstractValidator
Abstract
This is a base class for validators
- **`Phalcon\Filter\Validation\AbstractValidator`** - implements [`Phalcon\Filter\Validation\ValidatorInterface`](#filtervalidationvalidatorinterface)
- [`Phalcon\Filter\Validation\AbstractCombinedFieldsValidator`](#filtervalidationabstractcombinedfieldsvalidator)
- [`Phalcon\Filter\Validation\AbstractValidatorComposite`](#filtervalidationabstractvalidatorcomposite)
- [`Phalcon\Filter\Validation\Validator\Alnum`](#filtervalidationvalidatoralnum)
- [`Phalcon\Filter\Validation\Validator\Alpha`](#filtervalidationvalidatoralpha)
- [`Phalcon\Filter\Validation\Validator\Between`](#filtervalidationvalidatorbetween)
- [`Phalcon\Filter\Validation\Validator\Callback`](#filtervalidationvalidatorcallback)
- [`Phalcon\Filter\Validation\Validator\Confirmation`](#filtervalidationvalidatorconfirmation)
- [`Phalcon\Filter\Validation\Validator\CreditCard`](#filtervalidationvalidatorcreditcard)
- [`Phalcon\Filter\Validation\Validator\Date`](#filtervalidationvalidatordate)
- [`Phalcon\Filter\Validation\Validator\Digit`](#filtervalidationvalidatordigit)
- [`Phalcon\Filter\Validation\Validator\Email`](#filtervalidationvalidatoremail)
- [`Phalcon\Filter\Validation\Validator\ExclusionIn`](#filtervalidationvalidatorexclusionin)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- [`Phalcon\Filter\Validation\Validator\Files`](#filtervalidationvalidatorfiles)
- [`Phalcon\Filter\Validation\Validator\Identical`](#filtervalidationvalidatoridentical)
- [`Phalcon\Filter\Validation\Validator\InclusionIn`](#filtervalidationvalidatorinclusionin)
- [`Phalcon\Filter\Validation\Validator\Ip`](#filtervalidationvalidatorip)
- [`Phalcon\Filter\Validation\Validator\Numericality`](#filtervalidationvalidatornumericality)
- [`Phalcon\Filter\Validation\Validator\PresenceOf`](#filtervalidationvalidatorpresenceof)
- [`Phalcon\Filter\Validation\Validator\Regex`](#filtervalidationvalidatorregex)
- [`Phalcon\Filter\Validation\Validator\StringLength\Max`](#filtervalidationvalidatorstringlengthmax)
- [`Phalcon\Filter\Validation\Validator\StringLength\Min`](#filtervalidationvalidatorstringlengthmin)
- [`Phalcon\Filter\Validation\Validator\Url`](#filtervalidationvalidatorurl)
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Exceptions\FieldNotPrintable` · `Phalcon\Messages\Message` · `Phalcon\Support\Helper\Arr\Whitelist`
### Method Summary
Phalcon\Filter\Validation\Validator constructor
Returns an option in the validator's options
Get the template message
Get templates collection object
Checks if an option is defined
Checks whether the field can be considered empty and therefore
Create a default message by factory
Sets an option in the validator
Set a new template message
Clear current templates and set new from an array,
Executes the validation
Checks if field can be empty.
Checks if a value is an array and returns the element based on the
Prepares a validation code.
Prepares a label for the field.
Rejects a value that cannot be a string: an array, or an object without
### Properties
Message template
Whether the template/message has been explicitly assigned on the
instance (constructor `message`/`template` option or setTemplate()).
While false, `template` still holds the validator's class default and a
global default registered via Validation::setDefaultMessages() applies.
Message templates
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Phalcon\Filter\Validation\Validator constructor
getOption()
```php
public function getOption(
string $key,
mixed $defaultValue = null
): mixed;
```
Returns an option in the validator's options
Returns null if the option hasn't set
getTemplate()
```php
public function getTemplate( string|null $field = null ): string;
```
Get the template message
getTemplates()
```php
public function getTemplates(): array;
```
Get templates collection object
hasOption()
```php
public function hasOption( string $key ): bool;
```
Checks if an option is defined
isAllowEmpty()
```php
public function isAllowEmpty(
Validation $validation,
string $field
): bool;
```
Checks whether the field can be considered empty and therefore
skipped, honoring the `allowEmpty` option (boolean flag, list of
empty values, or per-field map).
messageFactory()
```php
public function messageFactory(
Validation $validation,
mixed $field,
array $replacements = []
): Message;
```
Create a default message by factory
setOption()
```php
public function setOption(
string $key,
mixed $value
): void;
```
Sets an option in the validator
setTemplate()
```php
public function setTemplate( string $template ): ValidatorInterface;
```
Set a new template message
setTemplates()
```php
public function setTemplates( array $templates ): ValidatorInterface;
```
Clear current templates and set new from an array,
validate()
```php
abstract public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
allowEmpty()
```php
protected function allowEmpty(
mixed $field,
mixed $value
): bool;
```
Checks if field can be empty.
checkArray()
```php
protected function checkArray(
mixed $value,
string $field
): mixed;
```
Checks if a value is an array and returns the element based on the
passed field name
prepareCode()
```php
protected function prepareCode( string $field ): int;
```
Prepares a validation code.
prepareLabel()
```php
protected function prepareLabel(
Validation $validation,
string $field
): mixed;
```
Prepares a label for the field.
rejectNonStringable()
```php
protected function rejectNonStringable(
Validation $validation,
mixed $field,
mixed $value
): bool;
```
Rejects a value that cannot be a string: an array, or an object without
__toString(). A cast would turn an array into the constant "Array",
which satisfies the string checks. Appends the message and returns
true when the value is rejected.
## Filter\Validation\AbstractValidatorComposite
Abstract
This is a base class for combined fields validators
@todo Remove in v7. Kept only for backwards compatibility; compose
Phalcon\Filter\Validation\Traits\ValidatorCompositeTrait directly (with
extends AbstractValidator implements ValidatorCompositeInterface) instead of
extending this.
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\AbstractValidatorComposite`** - implements [`Phalcon\Filter\Validation\ValidatorCompositeInterface`](#filtervalidationvalidatorcompositeinterface)
- [`Phalcon\Filter\Validation\Validator\File`](#filtervalidationvalidatorfile)
- [`Phalcon\Filter\Validation\Validator\StringLength`](#filtervalidationvalidatorstringlength)
`Phalcon\Filter\Validation\Traits\ValidatorCompositeTrait`
## Filter\Validation\Exception
Class
Exceptions thrown in Phalcon\Filter\Validation\* classes will use this class
- `\Exception`
- **`Phalcon\Filter\Validation\Exception`**
- [`Phalcon\Filter\Validation\Exceptions\FieldNotPrintable`](#filtervalidationexceptionsfieldnotprintable)
- [`Phalcon\Filter\Validation\Exceptions\FilterServiceUnavailable`](#filtervalidationexceptionsfilterserviceunavailable)
- [`Phalcon\Filter\Validation\Exceptions\InvalidAllowedTypes`](#filtervalidationexceptionsinvalidallowedtypes)
- [`Phalcon\Filter\Validation\Exceptions\InvalidCallbackReturn`](#filtervalidationexceptionsinvalidcallbackreturn)
- [`Phalcon\Filter\Validation\Exceptions\InvalidDomainOption`](#filtervalidationexceptionsinvaliddomainoption)
- [`Phalcon\Filter\Validation\Exceptions\InvalidFieldType`](#filtervalidationexceptionsinvalidfieldtype)
- [`Phalcon\Filter\Validation\Exceptions\InvalidFilterService`](#filtervalidationexceptionsinvalidfilterservice)
- [`Phalcon\Filter\Validation\Exceptions\InvalidStrictOption`](#filtervalidationexceptionsinvalidstrictoption)
- [`Phalcon\Filter\Validation\Exceptions\InvalidValidationData`](#filtervalidationexceptionsinvalidvalidationdata)
- [`Phalcon\Filter\Validation\Exceptions\InvalidValidator`](#filtervalidationexceptionsinvalidvalidator)
- [`Phalcon\Filter\Validation\Exceptions\InvalidValidatorScope`](#filtervalidationexceptionsinvalidvalidatorscope)
- [`Phalcon\Filter\Validation\Exceptions\MissingMbstring`](#filtervalidationexceptionsmissingmbstring)
- [`Phalcon\Filter\Validation\Exceptions\NoDataToValidate`](#filtervalidationexceptionsnodatatovalidate)
- [`Phalcon\Filter\Validation\Exceptions\NoValidators`](#filtervalidationexceptionsnovalidators)
- [`Phalcon\Filter\Validation\Exceptions\NoValidatorsInComposite`](#filtervalidationexceptionsnovalidatorsincomposite)
- [`Phalcon\Filter\Validation\Exceptions\UniquenessConversionMustBeArray`](#filtervalidationexceptionsuniquenessconversionmustbearray)
- [`Phalcon\Filter\Validation\Exceptions\UniquenessModelRequired`](#filtervalidationexceptionsuniquenessmodelrequired)
- [`Phalcon\Filter\Validation\Exceptions\UniquenessOnlyForPhalconModel`](#filtervalidationexceptionsuniquenessonlyforphalconmodel)
- [`Phalcon\Filter\Validation\Exceptions\ValidationEntityNotObject`](#filtervalidationexceptionsvalidationentitynotobject)
## Filter\Validation\Exceptions\FieldNotPrintable
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\FieldNotPrintable`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\FilterServiceUnavailable
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\FilterServiceUnavailable`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidAllowedTypes
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidAllowedTypes`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidCallbackReturn
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidCallbackReturn`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidDomainOption
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidDomainOption`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidFieldType
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidFieldType`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidFilterService
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidFilterService`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidStrictOption
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidStrictOption`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidValidationData
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidValidationData`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidValidator
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidValidator`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\InvalidValidatorScope
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\InvalidValidatorScope`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\MissingMbstring
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\MissingMbstring`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\NoDataToValidate
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\NoDataToValidate`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\NoValidators
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\NoValidators`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\NoValidatorsInComposite
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\NoValidatorsInComposite`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct( string $className );
```
## Filter\Validation\Exceptions\UniquenessConversionMustBeArray
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\UniquenessConversionMustBeArray`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\UniquenessModelRequired
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\UniquenessModelRequired`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\UniquenessOnlyForPhalconModel
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\UniquenessOnlyForPhalconModel`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Exceptions\ValidationEntityNotObject
Class
- `\Exception`
- [`Phalcon\Filter\Validation\Exception`](#filtervalidationexception)
- **`Phalcon\Filter\Validation\Exceptions\ValidationEntityNotObject`**
`Phalcon\Filter\Validation\Exception`
### Method Summary
### Methods
__construct()
```php
public function __construct();
```
## Filter\Validation\Traits\ValidatorCompositeTrait
Trait
Shared validator collection state and combined validation for composite
validators.
- **`Phalcon\Filter\Validation\Traits\ValidatorCompositeTrait`**
`Phalcon\Contracts\Filter\FilterTypes`
[`Phalcon\Filter\Validation\AbstractValidatorComposite`](#filtervalidationabstractvalidatorcomposite)
### Method Summary
Executes the validation
### Properties
@todo Use a default [] once Zephir supports array trait defaults
### Methods
getValidators()
```php
public function getValidators(): array;
```
validate()
```php
public function validate(
\Phalcon\Filter\Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\ValidationInterface
Interface
Interface for the Phalcon\Filter\Validation component
- **`Phalcon\Filter\Validation\ValidationInterface`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Di\Injectable` · `Phalcon\Messages\MessageInterface` · `Phalcon\Messages\Messages`
### Method Summary
Adds a validator to a field
Appends a message to the messages list
Assigns the data to an entity
Returns the bound entity
Returns all the filters or a specific one
Get label for field
Returns the registered validators
Returns the validators added to the validation
Gets the a value to validate in the array/object data source
Alias of `add` method
Adds the validators to a field
Adds filters to the field
Adds labels for fields
Validate a set of data according to a set of rules
### Methods
add()
```php
public function add(
mixed $field,
ValidatorInterface $validator
): ValidationInterface;
```
Adds a validator to a field
appendMessage()
```php
public function appendMessage( MessageInterface $message ): ValidationInterface;
```
Appends a message to the messages list
bind()
```php
public function bind(
mixed $entity,
mixed $data,
array $whitelist = []
): ValidationInterface;
```
Assigns the data to an entity
The entity is used to obtain the validation values
getEntity()
```php
public function getEntity(): mixed;
```
Returns the bound entity
getFilters()
```php
public function getFilters( string|null $field = null ): mixed|null;
```
Returns all the filters or a specific one
getLabel()
```php
public function getLabel( string $field ): string;
```
Get label for field
getMessages()
```php
public function getMessages(): Messages;
```
Returns the registered validators
getValidators()
```php
public function getValidators(): array;
```
Returns the validators added to the validation
getValue()
```php
public function getValue( string $field ): mixed|null;
```
Gets the a value to validate in the array/object data source
rule()
```php
public function rule(
mixed $field,
ValidatorInterface $validator
): ValidationInterface;
```
Alias of `add` method
rules()
```php
public function rules(
string $field,
array $validators
): ValidationInterface;
```
Adds the validators to a field
setFilters()
```php
public function setFilters(
string $field,
mixed $filters
): ValidationInterface;
```
Adds filters to the field
setLabels()
```php
public function setLabels( array $labels ): void;
```
Adds labels for fields
validate()
```php
public function validate(
mixed $data = null,
mixed $entity = null,
array $whitelist = []
): Messages|bool;
```
Validate a set of data according to a set of rules
## Filter\Validation\ValidatorCompositeInterface
Interface
This is a base class for combined fields validators
- **`Phalcon\Filter\Validation\ValidatorCompositeInterface`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation`
### Method Summary
Executes the validation
Executes the validation
### Methods
getValidators()
```php
public function getValidators(): array;
```
Executes the validation
```php
public function __construct( array $services = [] );
```
Constructor.
newInstance()
```php
public function newInstance( string $name ): ValidatorInterface;
```
Creates a new instance
getExceptionClass()
```php
protected function getExceptionClass(): string;
```
getServices()
```php
protected function getServices(): array;
```
Returns the available adapters
## Filter\Validation\ValidatorInterface
Interface
Interface for Phalcon\Filter\Validation\AbstractValidator
- **`Phalcon\Filter\Validation\ValidatorInterface`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation`
### Method Summary
Returns an option in the validator's options
Get the template message
Get message templates
Checks if an option is defined
Set a new template message
Clear current template and set new from an array,
Executes the validation
### Methods
getOption()
```php
public function getOption(
string $key,
mixed $defaultValue = null
): mixed;
```
Returns an option in the validator's options
Returns null if the option hasn't set
getTemplate()
```php
public function getTemplate( string $field ): string;
```
Get the template message
getTemplates()
```php
public function getTemplates(): array;
```
Get message templates
hasOption()
```php
public function hasOption( string $key ): bool;
```
Checks if an option is defined
setTemplate()
```php
public function setTemplate( string $template ): ValidatorInterface;
```
Set a new template message
setTemplates()
```php
public function setTemplates( array $templates ): ValidatorInterface;
```
Clear current template and set new from an array,
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Alnum
Class
Check for alphanumeric character(s)
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Alnum as AlnumValidator;
$validator = new Validation();
$validator->add(
"username",
new AlnumValidator(
[
"message" => ":field must contain only alphanumeric characters",
]
)
);
$validator->add(
[
"username",
"name",
],
new AlnumValidator(
[
"message" => [
"username" => "username must contain only alphanumeric characters",
"name" => "name must contain only alphanumeric characters",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Alnum`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Alpha
Class
Check for alphabetic character(s)
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Alpha as AlphaValidator;
$validator = new Validation();
$validator->add(
"username",
new AlphaValidator(
[
"message" => ":field must contain only letters",
]
)
);
$validator->add(
[
"username",
"name",
],
new AlphaValidator(
[
"message" => [
"username" => "username must contain only letters",
"name" => "name must contain only letters",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Alpha`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Between
Class
Validates that a value is between an inclusive range of two values.
For a value x, the test is passed if minimum<=x<=maximum.
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Between;
$validator = new Validation();
$validator->add(
"price",
new Between(
[
"minimum" => 0,
"maximum" => 100,
"message" => "The price must be between 0 and 100",
]
)
);
$validator->add(
[
"price",
"amount",
],
new Between(
[
"minimum" => [
"price" => 0,
"amount" => 0,
],
"maximum" => [
"price" => 100,
"amount" => 50,
],
"message" => [
"price" => "The price must be between 0 and 100",
"amount" => "The amount must be between 0 and 50",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Between`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Callback
Class
Calls user function for validation
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Callback as CallbackValidator;
use Phalcon\Filter\Validation\Validator\Numericality as NumericalityValidator;
$validator = new Validation();
$validator->add(
["user", "admin"],
new CallbackValidator(
[
"message" => "There must be only an user or admin set",
"callback" => function($data) {
if (!empty($data->getUser()) && !empty($data->getAdmin())) {
return false;
}
return true;
}
]
)
);
$validator->add(
"amount",
new CallbackValidator(
[
"callback" => function($data) {
if (!empty($data->getProduct())) {
return new NumericalityValidator(
[
"message" => "Amount must be a number."
]
);
}
}
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Callback`**
`Closure` · `Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Filter\Validation\Exceptions\InvalidCallbackReturn` · `Phalcon\Filter\Validation\ValidatorInterface` · `ReflectionFunction`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Confirmation
Class
Checks that two values have the same value
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Confirmation;
$validator = new Validation();
$validator->add(
"password",
new Confirmation(
[
"message" => "Password does not match confirmation",
"with" => "confirmPassword",
]
)
);
$validator->add(
[
"password",
"email",
],
new Confirmation(
[
"message" => [
"password" => "Password does not match confirmation",
"email" => "Email does not match confirmation",
],
"with" => [
"password" => "confirmPassword",
"email" => "confirmEmail",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Confirmation`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Filter\Validation\Exceptions\MissingMbstring` · `Phalcon\Messages\Message` · `Phalcon\Traits\Php\InfoTrait`
### Method Summary
Constructor
Executes the validation
Compare strings
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
compare()
```php
final protected function compare(
string $a,
string $b
): bool;
```
Compare strings
## Filter\Validation\Validator\CreditCard
Class
Checks if a value has a valid credit card number
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\CreditCard as CreditCardValidator;
$validator = new Validation();
$validator->add(
"creditCard",
new CreditCardValidator(
[
"message" => "The credit card number is not valid",
]
)
);
$validator->add(
[
"creditCard",
"secondCreditCard",
],
new CreditCardValidator(
[
"message" => [
"creditCard" => "The credit card number is not valid",
"secondCreditCard" => "The second credit card number is not valid",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\CreditCard`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Date
Class
Checks if a value is a valid date
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Date as DateValidator;
$validator = new Validation();
$validator->add(
"date",
new DateValidator(
[
"format" => "d-m-Y",
"message" => "The date is invalid",
]
)
);
$validator->add(
[
"date",
"anotherDate",
],
new DateValidator(
[
"format" => [
"date" => "d-m-Y",
"anotherDate" => "Y-m-d",
],
"message" => [
"date" => "The date is invalid",
"anotherDate" => "The another date is invalid",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Date`**
`DateTime` · `Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Digit
Class
Check for numeric character(s)
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Digit as DigitValidator;
$validator = new Validation();
$validator->add(
"height",
new DigitValidator(
[
"message" => ":field must be numeric",
]
)
);
$validator->add(
[
"height",
"width",
],
new DigitValidator(
[
"message" => [
"height" => "height must be numeric",
"width" => "width must be numeric",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Digit`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Email
Class
Checks if a value has a correct e-mail format
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Email as EmailValidator;
$validator = new Validation();
$validator->add(
"email",
new EmailValidator(
[
"message" => "The e-mail is not valid",
]
)
);
$validator->add(
[
"email",
"anotherEmail",
],
new EmailValidator(
[
"message" => [
"email" => "The e-mail is not valid",
"anotherEmail" => "The another e-mail is not valid",
],
]
)
);
```
```php
$validator->add(
"täst@example.com",
new EmailValidator(
[
"message" => "The e-mail is not valid",
"allowUTF8" => true,
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Email`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Exception
Class
Exceptions thrown in Phalcon\Filter\Validation\Validator\* classes will use this
class
- `\Exception`
- **`Phalcon\Filter\Validation\Validator\Exception`**
## Filter\Validation\Validator\ExclusionIn
Class
Check if a value is not included into a list of values
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\ExclusionIn;
$validator = new Validation();
$validator->add(
"status",
new ExclusionIn(
[
"message" => "The status must not be A or B",
"domain" => [
"A",
"B",
],
]
)
);
$validator->add(
[
"status",
"type",
],
new ExclusionIn(
[
"message" => [
"status" => "The status must not be A or B",
"type" => "The type must not be 1 or "
],
"domain" => [
"status" => [
"A",
"B",
],
"type" => [1, 2],
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\ExclusionIn`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Filter\Validation\Exceptions\InvalidDomainOption` · `Phalcon\Filter\Validation\Exceptions\InvalidStrictOption` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File
Class
Checks if a value has a correct file
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File as FileValidator;
$validator = new Validation();
$validator->add(
"file",
new FileValidator(
[
"maxSize" => "2M",
"messageSize" => ":field exceeds the max file size (:size)",
"allowedTypes" => [
"image/jpeg",
"image/png",
],
"messageType" => "Allowed file types are :types",
"maxResolution" => "800x600",
"messageMaxResolution" => "Max resolution of :field is :resolution",
"messageFileEmpty" => "File is empty",
"messageIniSize" => "Ini size is not valid",
"messageValid" => "File is not valid",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new FileValidator(
[
"maxSize" => [
"file" => "2M",
"anotherFile" => "4M",
],
"messageSize" => [
"file" => "file exceeds the max file size 2M",
"anotherFile" => "anotherFile exceeds the max file size 4M",
"allowedTypes" => [
"file" => [
"image/jpeg",
"image/png",
],
"anotherFile" => [
"image/gif",
"image/bmp",
],
],
"messageType" => [
"file" => "Allowed file types are image/jpeg and image/png",
"anotherFile" => "Allowed file types are image/gif and image/bmp",
],
"maxResolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"messageMaxResolution" => [
"file" => "Max resolution of file is 800x600",
"anotherFile" => "Max resolution of file is 1024x768",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\AbstractValidatorComposite`](#filtervalidationabstractvalidatorcomposite)
- **`Phalcon\Filter\Validation\Validator\File`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidatorComposite` · `Phalcon\Filter\Validation\Validator\File\MimeType` · `Phalcon\Filter\Validation\Validator\File\Resolution\AspectRatio` · `Phalcon\Filter\Validation\Validator\File\Resolution\Equal` · `Phalcon\Filter\Validation\Validator\File\Resolution\Max` · `Phalcon\Filter\Validation\Validator\File\Resolution\Min` · `Phalcon\Filter\Validation\Validator\File\Size\Equal` · `Phalcon\Filter\Validation\Validator\File\Size\Max` · `Phalcon\Filter\Validation\Validator\File\Size\Min` · `Phalcon\Messages\Message` · `Phalcon\Traits\Support\Helper\Arr\GetTrait`
### Method Summary
Constructor
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
## Filter\Validation\Validator\File\AbstractFile
Abstract
Checks if a value has a correct file
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Size(
[
"maxSize" => "2M",
"messageSize" => ":field exceeds the max file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new FileValidator(
[
"maxSize" => [
"file" => "2M",
"anotherFile" => "4M",
],
"messageSize" => [
"file" => "file exceeds the max file size 2M",
"anotherFile" => "anotherFile exceeds the max file size 4M",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\File\AbstractFile`**
- [`Phalcon\Filter\Validation\Validator\File\MimeType`](#filtervalidationvalidatorfilemimetype)
- [`Phalcon\Filter\Validation\Validator\File\Resolution\AspectRatio`](#filtervalidationvalidatorfileresolutionaspectratio)
- [`Phalcon\Filter\Validation\Validator\File\Resolution\Equal`](#filtervalidationvalidatorfileresolutionequal)
- [`Phalcon\Filter\Validation\Validator\File\Resolution\Max`](#filtervalidationvalidatorfileresolutionmax)
- [`Phalcon\Filter\Validation\Validator\File\Resolution\Min`](#filtervalidationvalidatorfileresolutionmin)
- [`Phalcon\Filter\Validation\Validator\File\Size\Equal`](#filtervalidationvalidatorfilesizeequal)
`Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Messages\Message`
### Method Summary
Check upload
Check if upload is empty
Check if upload is valid
Check if uploaded file is larger than PHP allowed size
Convert a string like "2.5MB" in bytes
Empty is empty
File exceeds the file size set in PHP configuration
File is not valid
Check on empty
Empty is empty
File exceeds the file size set in PHP configuration
File is not valid
Appends the "file is not valid" message for the field
Checks if a file has been uploaded; Internal check that can be
### Properties
Empty is empty
File exceeds the file size set in PHP configuration
File is not valid
### Methods
checkUpload()
```php
public function checkUpload(
Validation $validation,
string $field
): bool;
```
Check upload
checkUploadIsEmpty()
```php
public function checkUploadIsEmpty(
Validation $validation,
string $field
): bool;
```
Check if upload is empty
checkUploadIsValid()
```php
public function checkUploadIsValid(
Validation $validation,
string $field
): bool;
```
Check if upload is valid
checkUploadMaxSize()
```php
public function checkUploadMaxSize(
Validation $validation,
string $field
): bool;
```
Check if uploaded file is larger than PHP allowed size
getFileSizeInBytes()
```php
public function getFileSizeInBytes( string $size ): float;
```
Convert a string like "2.5MB" in bytes
getMessageFileEmpty()
```php
public function getMessageFileEmpty(): string;
```
Empty is empty
getMessageIniSize()
```php
public function getMessageIniSize(): string;
```
File exceeds the file size set in PHP configuration
getMessageValid()
```php
public function getMessageValid(): string;
```
File is not valid
isAllowEmpty()
```php
public function isAllowEmpty(
Validation $validation,
string $field
): bool;
```
Check on empty
setMessageFileEmpty()
```php
public function setMessageFileEmpty( string $message ): void;
```
Empty is empty
setMessageIniSize()
```php
public function setMessageIniSize( string $message ): void;
```
File exceeds the file size set in PHP configuration
setMessageValid()
```php
public function setMessageValid( string $message ): void;
```
File is not valid
appendMessageValid()
```php
protected function appendMessageValid(
Validation $validation,
string $field
): void;
```
Appends the "file is not valid" message for the field
checkIsUploadedFile()
```php
protected function checkIsUploadedFile( string $name ): bool;
```
Checks if a file has been uploaded; Internal check that can be
overridden in a subclass if you do not want to check uploaded files
## Filter\Validation\Validator\File\MimeType
Class
Checks if a value has a correct file mime type
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\MimeType;
$validator = new Validation();
$validator->add(
"file",
new MimeType(
[
"types" => [
"image/jpeg",
"image/png",
],
"message" => "Allowed file types are :types"
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new MimeType(
[
"types" => [
"file" => [
"image/jpeg",
"image/png",
],
"anotherFile" => [
"image/gif",
"image/bmp",
],
],
"message" => [
"file" => "Allowed file types are image/jpeg and image/png",
"anotherFile" => "Allowed file types are image/gif and image/bmp",
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- **`Phalcon\Filter\Validation\Validator\File\MimeType`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Exceptions\InvalidAllowedTypes` · `Phalcon\Traits\Php\InfoTrait`
### Method Summary
Executes the validation
### Properties
### Methods
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File\Resolution\AspectRatio
Class
Checks if a file has the exact aspect ratio
The ratio is compared with integer cross-multiplication, so the image
dimensions must match the ratio exactly: 1920x1080 matches "16x9",
1366x768 does not.
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\AspectRatio;
$validator = new Validation();
$validator->add(
"file",
new AspectRatio(
[
"ratio" => "16x9",
"message" => "The aspect ratio of the field :field has to be :ratio",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new AspectRatio(
[
"ratio" => [
"file" => "16x9",
"anotherFile" => "4x3",
],
"message" => [
"file" => "Aspect ratio of file has to be 16x9",
"anotherFile" => "Aspect ratio of anotherFile has to be 4x3",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- **`Phalcon\Filter\Validation\Validator\File\Resolution\AspectRatio`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Validator\File\AbstractFile`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File\Resolution\Equal
Class
Checks if a file has the right resolution
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Equal;
$validator = new Validation();
$validator->add(
"file",
new Equal(
[
"resolution" => "800x600",
"message" => "The resolution of the field :field has to be equal :resolution",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Equal(
[
"resolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"message" => [
"file" => "Equal resolution of file has to be 800x600",
"anotherFile" => "Equal resolution of file has to be 1024x768",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- **`Phalcon\Filter\Validation\Validator\File\Resolution\Equal`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Validator\File\AbstractFile` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File\Resolution\Max
Class
Checks if a file has the right resolution
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Max;
$validator = new Validation();
$validator->add(
"file",
new Max(
[
"resolution" => "800x600",
"message" => "Max resolution of :field is :resolution",
"included" => true,
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Max(
[
"resolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "Max resolution of file is 800x600",
"anotherFile" => "Max resolution of file is 1024x768",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- **`Phalcon\Filter\Validation\Validator\File\Resolution\Max`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Validator\File\AbstractFile` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File\Resolution\Min
Class
Checks if a file has the right resolution
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Resolution\Min;
$validator = new Validation();
$validator->add(
"file",
new Min(
[
"resolution" => "800x600",
"message" => "Min resolution of :field is :resolution",
"included" => true,
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Min(
[
"resolution" => [
"file" => "800x600",
"anotherFile" => "1024x768",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "Min resolution of file is 800x600",
"anotherFile" => "Min resolution of file is 1024x768",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- **`Phalcon\Filter\Validation\Validator\File\Resolution\Min`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Validator\File\AbstractFile` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File\Size\Equal
Class
Checks if a value has a correct file
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Equal(
[
"size" => "2M",
"included" => true,
"message" => ":field exceeds the equal file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Equal(
[
"size" => [
"file" => "2M",
"anotherFile" => "4M",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "file does not have the right file size",
"anotherFile" => "anotherFile wrong file size (4MB)",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- **`Phalcon\Filter\Validation\Validator\File\Size\Equal`**
- [`Phalcon\Filter\Validation\Validator\File\Size\Max`](#filtervalidationvalidatorfilesizemax)
- [`Phalcon\Filter\Validation\Validator\File\Size\Min`](#filtervalidationvalidatorfilesizemin)
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\Validator\File\AbstractFile`
### Method Summary
Executes the validation
Executes the conditional
### Properties
### Methods
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
getConditional()
```php
protected function getConditional(
float $source,
float $target,
bool $included = false
);
```
Executes the conditional
## Filter\Validation\Validator\File\Size\Max
Class
Checks if a value has a correct file
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Max(
[
"size" => "2M",
"included" => true,
"message" => ":field exceeds the max file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Max(
[
"size" => [
"file" => "2M",
"anotherFile" => "4M",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "file exceeds the max file size 2M",
"anotherFile" => "anotherFile exceeds the max file size 4M",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- [`Phalcon\Filter\Validation\Validator\File\Size\Equal`](#filtervalidationvalidatorfilesizeequal)
- **`Phalcon\Filter\Validation\Validator\File\Size\Max`**
### Method Summary
Executes the conditional
### Properties
### Methods
getConditional()
```php
protected function getConditional(
float $source,
float $target,
bool $included = false
);
```
Executes the conditional
## Filter\Validation\Validator\File\Size\Min
Class
Checks if a value has a correct file
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\File\Size;
$validator = new Validation();
$validator->add(
"file",
new Min(
[
"size" => "2M",
"included" => true,
"message" => ":field exceeds the min file size (:size)",
]
)
);
$validator->add(
[
"file",
"anotherFile",
],
new Min(
[
"size" => [
"file" => "2M",
"anotherFile" => "4M",
],
"included" => [
"file" => false,
"anotherFile" => true,
],
"message" => [
"file" => "file exceeds the min file size 2M",
"anotherFile" => "anotherFile exceeds the min file size 4M",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\Validator\File\AbstractFile`](#filtervalidationvalidatorfileabstractfile)
- [`Phalcon\Filter\Validation\Validator\File\Size\Equal`](#filtervalidationvalidatorfilesizeequal)
- **`Phalcon\Filter\Validation\Validator\File\Size\Min`**
### Method Summary
Executes the conditional
### Properties
### Methods
getConditional()
```php
protected function getConditional(
float $source,
float $target,
bool $included = false
);
```
Executes the conditional
## Filter\Validation\Validator\Files
Class
Validates an array of uploaded files by delegating each file to the `File`
validator. Accepts the same options as `Phalcon\Filter\Validation\Validator\File`
and forwards them to each delegated file. A standard multiple-file upload
(``) arrives as a transposed
`$_FILES` node; this validator normalizes it into individual files and fails
on the first file that violates a rule.
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Files as FilesValidator;
$validation = new Validation();
$validation->add(
"photos",
new FilesValidator(
[
"maxSize" => "2M",
"messageSize" => ":field exceeds the max file size (:size)",
"allowedTypes" => ["image/jpeg", "image/png"],
"messageType" => "Allowed file types are :types",
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Files`**
`Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Messages\Messages`
### Method Summary
Whole-field empty check: true when the field carries no uploaded files.
Executes the validation, delegating each file to a `File` validator.
Normalizes a single file or a transposed multi-file `$_FILES` node into a
### Methods
isAllowEmpty()
```php
public function isAllowEmpty(
Validation $validation,
string $field
): bool;
```
Whole-field empty check: true when the field carries no uploaded files.
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation, delegating each file to a `File` validator.
normalizeFiles()
```php
protected function normalizeFiles( mixed $value ): array;
```
Normalizes a single file or a transposed multi-file `$_FILES` node into a
list of single-file structures.
## Filter\Validation\Validator\Identical
Class
Checks if a value is identical to other
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Identical;
$validator = new Validation();
$validator->add(
"terms",
new Identical(
[
"accepted" => "yes",
"message" => "Terms and conditions must be accepted",
]
)
);
$validator->add(
[
"terms",
"anotherTerms",
],
new Identical(
[
"accepted" => [
"terms" => "yes",
"anotherTerms" => "yes",
],
"message" => [
"terms" => "Terms and conditions must be accepted",
"anotherTerms" => "Another terms must be accepted",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Identical`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\InclusionIn
Class
Check if a value is included into a list of values
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\InclusionIn;
$validator = new Validation();
$validator->add(
"status",
new InclusionIn(
[
"message" => "The status must be A or B",
"domain" => ["A", "B"],
]
)
);
$validator->add(
[
"status",
"type",
],
new InclusionIn(
[
"message" => [
"status" => "The status must be A or B",
"type" => "The status must be 1 or 2",
],
"domain" => [
"status" => ["A", "B"],
"type" => [1, 2],
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\InclusionIn`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Filter\Validation\Exceptions\InvalidDomainOption` · `Phalcon\Filter\Validation\Exceptions\InvalidStrictOption` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Ip
Class
Check for IP addresses
```php
use Phalcon\Filter\Validation\Validator\Ip as IpValidator;
$validator->add(
"ip_address",
new IpValidator(
[
"message" => ":field must contain only ip addresses",
"version" => IP::VERSION_4 | IP::VERSION_6, // v6 and v4. The same if not specified
"allowReserved" => false, // False if not specified. Ignored for v6
"allowPrivate" => false, // False if not specified
"allowEmpty" => false,
]
)
);
$validator->add(
[
"source_address",
"destination_address",
],
new IpValidator(
[
"message" => [
"source_address" => "source_address must be a valid IP address",
"destination_address" => "destination_address must be a valid IP address",
],
"version" => [
"source_address" => Ip::VERSION_4 | IP::VERSION_6,
"destination_address" => Ip::VERSION_4,
],
"allowReserved" => [
"source_address" => false,
"destination_address" => true,
],
"allowPrivate" => [
"source_address" => false,
"destination_address" => true,
],
"allowEmpty" => [
"source_address" => false,
"destination_address" => true,
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Ip`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Constants
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Numericality
Class
Check for a valid numeric value
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Numericality;
$validator = new Validation();
$validator->add(
"price",
new Numericality(
[
"message" => ":field is not numeric",
]
)
);
$validator->add(
[
"price",
"amount",
],
new Numericality(
[
"message" => [
"price" => "price is not numeric",
"amount" => "amount is not numeric",
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Numericality`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\PresenceOf
Class
Validates that a value is not null or empty string
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\PresenceOf;
$validator = new Validation();
$validator->add(
"name",
new PresenceOf(
[
"message" => "The name is required",
]
)
);
$validator->add(
[
"name",
"email",
],
new PresenceOf(
[
"message" => [
"name" => "The name is required",
"email" => "The email is required",
],
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\PresenceOf`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Regex
Class
Allows validate if the value of a field matches a regular expression
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Regex as RegexValidator;
$validator = new Validation();
$validator->add(
"created_at",
new RegexValidator(
[
"pattern" => "/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/",
"message" => "The creation date is invalid",
]
)
);
$validator->add(
[
"created_at",
"name",
],
new RegexValidator(
[
"pattern" => [
"created_at" => "/^[0-9]{4}[-\/](0[1-9]|1[12])[-\/](0[1-9]|[12][0-9]|3[01])$/",
"name" => "/^[a-z]$/",
],
"message" => [
"created_at" => "The creation date is invalid",
"name" => "The name is invalid",
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Regex`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Messages\Message`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\StringLength
Class
Validates that a string has the specified maximum and minimum constraints
The test is passed if for a string's length L, min<=L<=max, i.e. L must
be at least min, and at most max.
Since Phalcon v4.0 this validator works like a container
The "includedMinimum" and "includedMaximum" options are true by
default. Set an option to false to exclude that boundary. The two
options are independent of each other. The "included" option sets
the two boundaries together and has precedence.
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength as StringLength;
$validator = new Validation();
$validation->add(
"name_last",
new StringLength(
[
"max" => 50,
"min" => 2,
"messageMaximum" => "We don't like really long names",
"messageMinimum" => "We want more than just their initials",
"includedMaximum" => true,
"includedMinimum" => false,
]
)
);
$validation->add(
[
"name_last",
"name_first",
],
new StringLength(
[
"max" => [
"name_last" => 50,
"name_first" => 40,
],
"min" => [
"name_last" => 2,
"name_first" => 4,
],
"messageMaximum" => [
"name_last" => "We don't like really long last names",
"name_first" => "We don't like really long first names",
],
"messageMinimum" => [
"name_last" => "We don't like too short last names",
"name_first" => "We don't like too short first names",
],
"includedMaximum" => [
"name_last" => false,
"name_first" => true,
],
"includedMinimum" => [
"name_last" => false,
"name_first" => true,
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\AbstractValidatorComposite`](#filtervalidationabstractvalidatorcomposite)
- **`Phalcon\Filter\Validation\Validator\StringLength`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation\AbstractValidatorComposite` · `Phalcon\Filter\Validation\Exception` · `Phalcon\Filter\Validation\Validator\StringLength\Max` · `Phalcon\Filter\Validation\Validator\StringLength\Min` · `Phalcon\Messages\Message`
### Method Summary
Constructor
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
## Filter\Validation\Validator\StringLength\Max
Class
Validates that a string has the specified maximum constraints
The test is passed if for a string's length L, L<=max, i.e. L must
be at most max.
The "included" option is true by default. Set the option to false
for L<max, i.e. L must be less than max. The "includedMaximum" option
is an alias of "included". If you set the two options, "included" has
precedence.
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength\Max;
$validator = new Validation();
$validation->add(
"name_last",
new Max(
[
"max" => 50,
"message" => "We don't like really long names",
"included" => true
]
)
);
$validation->add(
[
"name_last",
"name_first",
],
new Max(
[
"max" => [
"name_last" => 50,
"name_first" => 40,
],
"message" => [
"name_last" => "We don't like really long last names",
"name_first" => "We don't like really long first names",
],
"included" => [
"name_last" => false,
"name_first" => true,
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\StringLength\Max`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Messages\Message` · `Phalcon\Traits\Php\InfoTrait`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\StringLength\Min
Class
Validates that a string has the specified minimum constraints
The test is passed if for a string's length L, min<=L, i.e. L must
be at least min.
The "included" option is true by default. Set the option to false
for min<L, i.e. L must be more than min. The "includedMinimum" option
is an alias of "included". If you set the two options, "included" has
precedence.
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\StringLength\Min;
$validator = new Validation();
$validation->add(
"name_last",
new Min(
[
"min" => 2,
"message" => "We want more than just their initials",
"included" => false
]
)
);
$validation->add(
[
"name_last",
"name_first",
],
new Min(
[
"min" => [
"name_last" => 2,
"name_first" => 4,
],
"message" => [
"name_last" => "We don't like too short last names",
"name_first" => "We don't like too short first names",
],
"included" => [
"name_last" => false,
"name_first" => true,
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\StringLength\Min`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator` · `Phalcon\Messages\Message` · `Phalcon\Traits\Php\InfoTrait`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\Uniqueness
Class
Check that a field is unique in the related table
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Uniqueness as UniquenessValidator;
$validator = new Validation();
$validator->add(
"username",
new UniquenessValidator(
[
"model" => new Users(),
"message" => ":field must be unique",
]
)
);
```
Different attribute from the field:
```php
$validator->add(
"username",
new UniquenessValidator(
[
"model" => new Users(),
"attribute" => "nick",
]
)
);
```
In model:
```php
$validator->add(
"username",
new UniquenessValidator()
);
```
Combination of fields in model:
```php
$validator->add(
[
"firstName",
"lastName",
],
new UniquenessValidator()
);
```
It is possible to convert values before validation. This is useful in
situations where values need to be converted to do the database lookup:
```php
$validator->add(
"username",
new UniquenessValidator(
[
"convert" => function (array $values) {
$values["username"] = strtolower($values["username"]);
return $values;
}
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- [`Phalcon\Filter\Validation\AbstractCombinedFieldsValidator`](#filtervalidationabstractcombinedfieldsvalidator)
- **`Phalcon\Filter\Validation\Validator\Uniqueness`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractCombinedFieldsValidator` · `Phalcon\Filter\Validation\Exception` · `Phalcon\Filter\Validation\Exceptions\UniquenessConversionMustBeArray` · `Phalcon\Filter\Validation\Exceptions\UniquenessModelRequired` · `Phalcon\Filter\Validation\Exceptions\UniquenessOnlyForPhalconModel` · `Phalcon\Messages\Message` · `Phalcon\Mvc\Model` · `Phalcon\Mvc\ModelInterface` · `Phalcon\Support\Settings`
### Method Summary
Constructor
Returns an option in the validator's options
Executes the validation
The column map is used in the case to get real column name
Uniqueness method used for model
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
getOption()
```php
public function getOption(
string $key,
mixed $defaultValue = null
): mixed;
```
Returns an option in the validator's options
Returns null if the option hasn't set
The `attribute` option can be defined as an array when validating a
combination of fields; in that case resolve it to the mapped value.
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
getColumnNameReal()
```php
protected function getColumnNameReal(
mixed $record,
string $field
): string;
```
The column map is used in the case to get real column name
```php
protected function isUniquenessModel(
mixed $record,
array $field,
array $values
);
```
Uniqueness method used for model
## Filter\Validation\Validator\Url
Class
Checks if a value has a url format
```php
use Phalcon\Filter\Validation;
use Phalcon\Filter\Validation\Validator\Url as UrlValidator;
$validator = new Validation();
$validator->add(
"url",
new UrlValidator(
[
"message" => ":field must be a url",
]
)
);
$validator->add(
[
"url",
"homepage",
],
new UrlValidator(
[
"message" => [
"url" => "url must be a url",
"homepage" => "homepage must be a url",
]
]
)
);
```
- [`Phalcon\Filter\Validation\AbstractValidator`](#filtervalidationabstractvalidator)
- **`Phalcon\Filter\Validation\Validator\Url`**
`Phalcon\Contracts\Filter\FilterTypes` · `Phalcon\Filter\Validation` · `Phalcon\Filter\Validation\AbstractValidator`
### Method Summary
Constructor
Executes the validation
### Properties
### Methods
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
Source: https://docs.phalcon.io/5.20/api/phalcon_filter/index.mdx