---
title: "Phalcon Filter"
version: "5.17"
---
> 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 $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;
```
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 $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\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 $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 ): double;
```
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(
double $source,
double $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
```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.
```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.
```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" => true
]
)
);
$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",
]
]
)
);
```