---
title: "Phalcon Filter"
version: "5.19"
---
> 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
ClassSource on GitHub
Phalcon\Filter\Exception
Exceptions thrown in Phalcon\Filter will use this class
```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
Protected · 1
init()
```php
protected function init( array $mapper ): void;
```
Loads the objects in the internal mapper array
## Filter\FilterFactory
ClassSource on GitHub
Class FilterFactory
@package Phalcon\Filter
```php
public function newInstance(): FilterInterface;
```
Returns a Locator object with all the helpers defined in anonymous
functions
Protected · 1
getServices()
```php
protected function getServices(): array;
```
Returns the available adapters
## Filter\FilterInterface
InterfaceSource on GitHub
Lazy loads, stores and exposes sanitizer objects
```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
ClassSource on GitHub
Phalcon\Filter\Sanitize\AbsInt
Sanitizes a value to absolute integer
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Alnum
ClassSource on GitHub
Phalcon\Filter\Sanitize\Alnum
Sanitizes a value to an alphanumeric value
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Alpha
ClassSource on GitHub
Phalcon\Filter\Sanitize\Alpha
Sanitizes a value to an alpha value
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\BoolVal
ClassSource on GitHub
Phalcon\Filter\Sanitize\BoolVal
Sanitizes a value to boolean
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Email
ClassSource on GitHub
Phalcon\Filter\Sanitize\Email
Sanitizes an email string
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\FloatVal
ClassSource on GitHub
Phalcon\Filter\Sanitize\FloatVal
Sanitizes a value to float
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\IntVal
ClassSource on GitHub
Phalcon\Filter\Sanitize\IntVal
Sanitizes a value to integer
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Ip
ClassSource on GitHub
Phalcon\Filter\Sanitize\IP
Sanitizes a value to an ip address or CIDR range
```php
public function __invoke(
string $input,
int $filter = 0
): string|false;
```
## Filter\Sanitize\Lower
ClassSource on GitHub
Phalcon\Filter\Sanitize\Lower
Sanitizes a value to lowercase
```php
public function __invoke( string $input );
```
## Filter\Sanitize\LowerFirst
ClassSource on GitHub
Phalcon\Filter\Sanitize\LowerFirst
Sanitizes a value to lcfirst
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Regex
ClassSource on GitHub
Phalcon\Filter\Sanitize\Regex
Sanitizes a value performing preg_replace
```php
public function __invoke(
mixed $input,
mixed $pattern,
mixed $replace
);
```
## Filter\Sanitize\Remove
ClassSource on GitHub
Phalcon\Filter\Sanitize\Remove
Sanitizes a value removing parts of a string
```php
public function __invoke(
mixed $input,
mixed $replace
);
```
## Filter\Sanitize\Replace
ClassSource on GitHub
Phalcon\Filter\Sanitize\Replace
Sanitizes a value replacing parts of a string
```php
public function __invoke(
mixed $input,
mixed $from,
mixed $to
);
```
## Filter\Sanitize\Special
ClassSource on GitHub
Phalcon\Filter\Sanitize\Special
Sanitizes a value special characters
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\SpecialFull
ClassSource on GitHub
Phalcon\Filter\Sanitize\SpecialFull
Sanitizes a value special characters (htmlspecialchars() and ENT_QUOTES)
```php
public function __invoke(
string $input,
int $flags = 11
): string;
```
## Filter\Sanitize\StringValLegacy
ClassSource on GitHub
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
```php
public function __invoke( mixed $input );
```
## Filter\Sanitize\Striptags
ClassSource on GitHub
Phalcon\Filter\Sanitize\Striptags
Sanitizes a value striptags
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Trim
ClassSource on GitHub
Phalcon\Filter\Sanitize\Trim
Sanitizes a value removing leading and trailing spaces
```php
public function __invoke( string $input );
```
## Filter\Sanitize\Upper
ClassSource on GitHub
Phalcon\Filter\Sanitize\Upper
Sanitizes a value to uppercase
```php
public function __invoke( string $input );
```
## Filter\Sanitize\UpperFirst
ClassSource on GitHub
Phalcon\Filter\Sanitize\UpperFirst
Sanitizes a value to ucfirst
```php
public function __invoke( string $input );
```
## Filter\Sanitize\UpperWords
ClassSource on GitHub
Phalcon\Filter\Sanitize\UpperWords
Sanitizes a value to uppercase the first character of each word
```php
public function __invoke( mixed $input );
```
## Filter\Validation
ClassSource on GitHub
Allows to validate data using custom or built-in validators
protectedarray$defaultMessages = []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.
protectedobject|null$entity = null
protectedarray$filters = []
protectedarray$labels = []
protectedMessages$messages
protectedarray$validators = []List of validators
protectedarray$values = []Calculated values
protectedarray$whitelist = []
### Methods
Public · 23
__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 a value to validate in the array/object data source
getValueByData()
```php
public function getValueByData(
mixed $data,
string $field
): mixed|null;
```
Gets the a value to validate in the array/object data source
getValueByEntity()
```php
public function getValueByEntity(
mixed $entity,
string $field
): mixed|null;
```
Gets the a value to validate in the object entity source
rule()
```php
public function rule(
mixed $field,
ValidatorInterface $validator
): static;
```
Alias of `add` method
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);
```
Protected · 1
preChecking()
```php
protected function preChecking(
mixed $field,
ValidatorInterface $validator
): bool;
```
Internal validations, if it returns true, then skip the current validator
## Filter\Validation\AbstractCombinedFieldsValidator
AbstractSource on GitHub
This is a base class for combined fields validators
protectedbool$templateChanged = falseWhether 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.
protectedarray$templates = []Message templates
### Methods
Public · 11
__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
Protected · 4
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.
## Filter\Validation\AbstractValidatorComposite
AbstractSource on GitHub
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.
__Uses__ `Phalcon\Filter\Validation\Traits\ValidatorCompositeTrait`
## Filter\Validation\Exception
ClassSource on GitHub
Exceptions thrown in Phalcon\Filter\Validation\* classes will use this class
```php
public function __construct();
```
## Filter\Validation\Traits\ValidatorCompositeTrait
TraitSource on GitHub
Shared validator collection state and combined validation for composite
validators.
protectedarray$validators = null@todo Use a default [] once Zephir supports array trait defaults
### Methods
Public · 2
getValidators()
```php
public function getValidators(): array;
```
validate()
```php
public function validate(
\Phalcon\Filter\Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\ValidationInterface
InterfaceSource on GitHub
Interface for the Phalcon\Filter\Validation component
```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
InterfaceSource on GitHub
This is a base class for combined fields validators
```php
public function getValidators(): array;
```
Executes the validation
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\ValidatorFactory
ClassSource on GitHub
```php
public function __construct( array $services = [] );
```
TagFactory constructor.
newInstance()
```php
public function newInstance( string $name ): ValidatorInterface;
```
Creates a new instance
Protected · 2
getExceptionClass()
```php
protected function getExceptionClass(): string;
```
getServices()
```php
protected function getServices(): array;
```
Returns the available adapters
## Filter\Validation\ValidatorInterface
InterfaceSource on GitHub
Interface for Phalcon\Filter\Validation\AbstractValidator
```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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field must contain only letters and numbers"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field must contain only letters"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field must be within the range of :min to :max"
### Methods
Public · 2
__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
ClassSource on GitHub
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."
]
);
}
}
]
)
);
```
protectedstring$template = "Field :field must match the callback function"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field must be the same as :with"
### Methods
Public · 2
__construct()
```php
public function __construct( array $options = [] );
```
Constructor
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
Protected · 1
compare()
```php
final protected function compare(
string $a,
string $b
): bool;
```
Compare strings
## Filter\Validation\Validator\CreditCard
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field is not valid for a credit card number"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field is not a valid date"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field must be numeric"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
$validator->add(
"täst@example.com",
new EmailValidator(
[
"message" => "The e-mail is not valid",
"allowUTF8" => true,
]
)
);
```
protectedstring$template = "Field :field must be an email address"
### Methods
Public · 2
__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
ClassSource on GitHub
Exceptions thrown in Phalcon\Filter\Validation\Validator\* classes will use this
class
## Filter\Validation\Validator\ExclusionIn
ClassSource on GitHub
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],
],
]
)
);
```
protectedstring$messageFileEmpty = "Field :field must not be empty"Empty is empty
protectedstring$messageIniSize = "File :field exceeds the maximum file size"File exceeds the file size set in PHP configuration
protectedstring$messageValid = "Field :field is not valid"File is not valid
### Methods
Public · 12
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
Protected · 1
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
ClassSource on GitHub
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",
]
]
)
);
```
protectedstring$template = "File :field must be of type: :types"
### Methods
Public · 1
validate()
```php
public function validate(
Validation $validation,
mixed $field
): bool;
```
Executes the validation
## Filter\Validation\Validator\File\Resolution\AspectRatio
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "File :field does not have the exact aspect ratio of :ratio"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring|null$template = "File :field can not have the minimum size of :size"
### Methods
Protected · 1
getConditional()
```php
protected function getConditional(
float $source,
float $target,
bool $included = false
);
```
Executes the conditional
## Filter\Validation\Validator\Files
ClassSource on GitHub
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",
]
)
);
```
```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.
Protected · 1
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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field does not have the expected value"
### Methods
Public · 2
__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
ClassSource on GitHub
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],
]
]
)
);
```
protectedstring$template = "Field :field must be a valid IP address"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
]
]
)
);
```
protectedstring$template = "Field :field does not have a valid numeric format"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
],
]
)
);
```
protectedstring$template = "Field :field is required"
### Methods
Public · 2
__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
ClassSource on GitHub
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",
]
]
)
);
```
protectedstring$template = "Field :field does not match the required format"
### Methods
Public · 2
__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
ClassSource on GitHub
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,
]
]
)
);
```
```php
public function __construct( array $options = [] );
```
Constructor
## Filter\Validation\Validator\StringLength\Max
ClassSource on GitHub
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,
]
]
)
);
```
protectedstring$template = "Field :field must not exceed :max characters long"
### Methods
Public · 2
__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
ClassSource on GitHub
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,
]
]
)
);
```
protectedstring$template = "Field :field must be at least :min characters long"
### Methods
Public · 2
__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
ClassSource on GitHub
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;
}
]
)
);
```
protectedstring$template = "Field :field must be unique"
### Methods
Public · 3
__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
Protected · 3
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
ClassSource on GitHub
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",
]
]
)
);
```