mirror of
https://github.com/yiisoft/yii2.git
synced 2025-08-26 14:26:54 +08:00
More spanish docs [skip ci] (#11640)
This commit is contained in:
Luciano Baraglia
committed by
Carsten Brandt
Carsten Brandt
parent
418de14730
commit
42db3687cb
714
docs/guide-es/input-validation.md
Normal file
714
docs/guide-es/input-validation.md
Normal file
@ -0,0 +1,714 @@
|
||||
Validación de Entrada
|
||||
=====================
|
||||
|
||||
Como regla básica, nunca debes confiar en los datos recibidos de un usuario final y deberías validarlo siempre
|
||||
antes de ponerlo en uso.
|
||||
|
||||
Dado un [modelo](structure-models.md) poblado con entradas de usuarios, puedes validar esas entradas llamando al
|
||||
método [[yii\base\Model::validate()]]. Dicho método devolverá un valor booleano indicando si la validación
|
||||
tuvo éxito o no. En caso de que no, puedes obtener los mensajes de error de la propiedad [[yii\base\Model::errors]]. Por ejemplo,
|
||||
|
||||
```php
|
||||
$model = new \app\models\ContactForm();
|
||||
|
||||
// poblar los atributos del modelo desde la entrada del usuario
|
||||
$model->load(\Yii::$app->request->post());
|
||||
// lo que es equivalente a:
|
||||
// $model->attributes = \Yii::$app->request->post('ContactForm');
|
||||
|
||||
if ($model->validate()) {
|
||||
// toda la entrada es válida
|
||||
} else {
|
||||
// la validación falló: $errors es un array que contienen los mensajes de error
|
||||
$errors = $model->errors;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
## Declarar Reglas <span id="declaring-rules"></span>
|
||||
|
||||
Para hacer que `validate()` realmente funcione, debes declarar reglas de validación para los atributos que planeas validar.
|
||||
Esto debería hacerse sobrescribiendo el método [[yii\base\Model::rules()]]. El siguiente ejemplo muestra cómo
|
||||
son declaradas las reglas de validación para el modelo `ContactForm`:
|
||||
|
||||
```php
|
||||
public function rules()
|
||||
{
|
||||
return [
|
||||
// los atributos name, email, subject y body son obligatorios
|
||||
[['name', 'email', 'subject', 'body'], 'required'],
|
||||
|
||||
// el atributo email debe ser una dirección de email válida
|
||||
['email', 'email'],
|
||||
];
|
||||
}
|
||||
```
|
||||
|
||||
El método [[yii\base\Model::rules()|rules()]] debe devolver un array de reglas, la cual cada una
|
||||
tiene el siguiente formato:
|
||||
|
||||
```php
|
||||
[
|
||||
// requerido, especifica qué atributos deben ser validados por esta regla.
|
||||
// Para un sólo atributo, puedes utilizar su nombre directamente
|
||||
// sin tenerlo dentro de un array
|
||||
['attribute1', 'attribute2', ...],
|
||||
|
||||
// requerido, especifica de qué tipo es la regla.
|
||||
// Puede ser un nombre de clase, un alias de validador, o el nombre de un método de validación
|
||||
'validator',
|
||||
|
||||
// opcional, especifica en qué escenario/s esta regla debe aplicarse
|
||||
// si no se especifica, significa que la regla se aplica en todos los escenarios
|
||||
// Puedes también configurar la opción "except" en caso de que quieras aplicar la regla
|
||||
// en todos los escenarios salvo los listados
|
||||
'on' => ['scenario1', 'scenario2', ...],
|
||||
|
||||
// opcional, especifica atributos adicionales para el objeto validador
|
||||
'property1' => 'value1', 'property2' => 'value2', ...
|
||||
]
|
||||
```
|
||||
|
||||
Por cada regla debes especificar al menos a cuáles atributos aplica la regla y cuál es el tipo de la regla.
|
||||
Puedes especificar el tipo de regla de las siguientes maneras:
|
||||
|
||||
* el alias de un validador propio del framework, tal como `required`, `in`, `date`, etc. Por favor consulta
|
||||
[Validadores del núcleo](tutorial-core-validators.md) para la lista completa de todos los validadores incluidos.
|
||||
* el nombre de un método de validación en la clase del modelo, o una función anónima. Consulta la
|
||||
subsección [Validadores en Línea](#inline-validators) para más detalles.
|
||||
* el nombre completo de una clase de validador. Por favor consulta la subsección [Validadores Independientes](#standalone-validators)
|
||||
para más detalles.
|
||||
|
||||
Una regla puede ser utilizada para validar uno o varios atributos, y un atributo puede ser validado por una o varias reglas.
|
||||
Una regla puede ser aplicada en ciertos [escenarios](structure-models.md#scenarios) con tan sólo especificando la opción `on`.
|
||||
Si no especificas una opción `on`, significa que la regla se aplicará en todos los escenarios.
|
||||
|
||||
Cuando el método `validate()` es llamado, este sigue los siguientes pasos para realiza la validación:
|
||||
|
||||
1. Determina cuáles atributos deberían ser validados obteniendo la lista de atributos de [[yii\base\Model::scenarios()]]
|
||||
utilizando el [[yii\base\Model::scenario|scenario]] actual. Estos atributos son llamados *atributos activos*.
|
||||
2. Determina cuáles reglas de validación deberían ser validados obteniendo la lista de reglas de [[yii\base\Model::rules()]]
|
||||
utilizando el [[yii\base\Model::scenario|scenario]] actual. Estas reglas son llamadas *reglas activas*.
|
||||
3. Utiliza cada regla activa para validar cada atributo activo que esté asociado a la regla.
|
||||
Las reglas de validación son evaluadas en el orden en que están listadas.
|
||||
|
||||
De acuerdo a los pasos de validación mostrados arriba, un atributo será validado si y sólo si
|
||||
es un atributo activo declarado en `scenarios()` y está asociado a una o varias reglas activas
|
||||
declaradas en `rules()`.
|
||||
|
||||
> Note: Es práctico darle nombre a las reglas, por ej:
|
||||
> ```php
|
||||
> public function rules()
|
||||
> {
|
||||
> return [
|
||||
> // ...
|
||||
> 'password' => [['password'], 'string', 'max' => 60],
|
||||
> ];
|
||||
> }
|
||||
> ```
|
||||
>
|
||||
> Puedes utilizarlas en una subclase del modelo:
|
||||
>
|
||||
> ```php
|
||||
> public function rules()
|
||||
> {
|
||||
> $rules = parent::rules();
|
||||
> unset($rules['password']);
|
||||
> return $rules;
|
||||
> }
|
||||
|
||||
|
||||
### Personalizar Mensajes de Error <span id="customizing-error-messages"></span>
|
||||
|
||||
La mayoría de los validadores tienen mensajes de error por defecto que serán agregados al modelo siendo validado cuando sus atributos
|
||||
fallan la validación. Por ejemplo, el validador [[yii\validators\RequiredValidator|required]] agregará
|
||||
el mensaje "Username no puede estar vacío." a un modelo cuando falla la validación del atributo `username` al utilizar esta regla.
|
||||
|
||||
Puedes especificar el mensaje de error de una regla especificado la propiedad `message` al declarar la regla,
|
||||
como a continuación,
|
||||
|
||||
```php
|
||||
public function rules()
|
||||
{
|
||||
return [
|
||||
['username', 'required', 'message' => 'Por favor escoge un nombre de usuario.'],
|
||||
];
|
||||
}
|
||||
```
|
||||
|
||||
Algunos validadores pueden soportar mensajes de error adicionales para describir más precisamente las causas
|
||||
del fallo de validación. Por ejemplo, el validador [[yii\validators\NumberValidator|number]] soporta
|
||||
[[yii\validators\NumberValidator::tooBig|tooBig]] y [[yii\validators\NumberValidator::tooSmall|tooSmall]]
|
||||
para describir si el fallo de validación es porque el valor siendo validado es demasiado grande o demasiado pequeño, respectivamente.
|
||||
Puedes configurar estos mensajes de error tal como cualquier otroa propiedad del validador en una regla de validación.
|
||||
|
||||
|
||||
### Eventos de Validación <span id="validation-events"></span>
|
||||
|
||||
Cuando el método [[yii\base\Model::validate()]] es llamado, este llamará a dos métodos que puedes sobrescribir para personalizar
|
||||
el proceso de validación:
|
||||
|
||||
* [[yii\base\Model::beforeValidate()]]: la implementación por defecto lanzará un evento [[yii\base\Model::EVENT_BEFORE_VALIDATE]].
|
||||
Puedes tanto sobrescribir este método o responder a este evento para realizar algún trabajo de pre procesamiento
|
||||
(por ej. normalizar datos de entrada) antes de que ocurra la validación en sí. El método debe devolver un booleano que indique
|
||||
si la validación debe continuar o no.
|
||||
* [[yii\base\Model::afterValidate()]]: la implementación por defecto lanzará un evento [[yii\base\Model::EVENT_AFTER_VALIDATE]].
|
||||
uedes tanto sobrescribir este método o responder a este evento para realizar algún trabajo de post procesamiento después
|
||||
de completada la validación.
|
||||
|
||||
|
||||
### Validación Condicional <span id="conditional-validation"></span>
|
||||
|
||||
Para validar atributos sólo en determinadas condiciones, por ej. la validación de un atributo depende
|
||||
del valor de otro atributo puedes utilizar la propiedad [[yii\validators\Validator::when|when]]
|
||||
para definir la condición. Por ejemplo,
|
||||
|
||||
```php
|
||||
['state', 'required', 'when' => function($model) {
|
||||
return $model->country == 'USA';
|
||||
}]
|
||||
```
|
||||
|
||||
La propiedad [[yii\validators\Validator::when|when]] toma un método invocable PHP con la siguiente firma:
|
||||
|
||||
```php
|
||||
/**
|
||||
* @param Model $model el modelo siendo validado
|
||||
* @param string $attribute al atributo siendo validado
|
||||
* @return boolean si la regla debe ser aplicada o no
|
||||
*/
|
||||
function ($model, $attribute)
|
||||
```
|
||||
|
||||
Si también necesitas soportar validación condicional del lado del cliente, debes configurar
|
||||
la propiedad [[yii\validators\Validator::whenClient|whenClient]], que toma un string que representa una función JavaScript
|
||||
cuyo valor de retorno determina si debe aplicarse la regla o no. Por ejemplo,
|
||||
|
||||
```php
|
||||
['state', 'required', 'when' => function ($model) {
|
||||
return $model->country == 'USA';
|
||||
}, 'whenClient' => "function (attribute, value) {
|
||||
return $('#country').val() == 'USA';
|
||||
}"]
|
||||
```
|
||||
|
||||
|
||||
### Filtro de Datos <span id="data-filtering"></span>
|
||||
|
||||
La entrada del usuario a menudo debe ser filtrada o pre procesada. Por ejemplo, podrías querer eliminar los espacions alrededor
|
||||
de la entrada `username`. Puedes utilizar reglas de validación para lograrlo.
|
||||
|
||||
Los siguientes ejemplos muestran cómo eliminar esos espacios en la entrada y cómo transformar entradas vacías en null utilizando
|
||||
los validadores del framework [trim](tutorial-core-validators.md#trim) y [default](tutorial-core-validators.md#default):
|
||||
|
||||
```php
|
||||
return [
|
||||
[['username', 'email'], 'trim'],
|
||||
[['username', 'email'], 'default'],
|
||||
];
|
||||
```
|
||||
|
||||
También puedes utilizar el validador más general [filter](tutorial-core-validators.md#filter) para realizar filtros
|
||||
de datos más complejos.
|
||||
|
||||
Como puedes ver, estas reglas de validación no validan la entrada realmente. En cambio, procesan los valores
|
||||
y los guardan en el atributo siendo validado.
|
||||
|
||||
|
||||
### Manejando Entradas Vacías <span id="handling-empty-inputs"></span>
|
||||
|
||||
Cuando los datos de entrada son enviados desde formularios HTML, a menudo necesitas asignar algunos valores por defecto a las entradas
|
||||
si estas están vacías. Puedes hacerlo utilizando el validador [default](tutorial-core-validators.md#default). Por ejemplo,
|
||||
|
||||
```php
|
||||
return [
|
||||
// convierte "username" y "email" en null si estos están vacíos
|
||||
[['username', 'email'], 'default'],
|
||||
|
||||
// convierte "level" a 1 si está vacío
|
||||
['level', 'default', 'value' => 1],
|
||||
];
|
||||
```
|
||||
|
||||
Por defecto, una entrada se considera vacía si su valor es un string vacío, un array vacío o null.
|
||||
Puedes personalizar la lógica de detección de valores vacíos configurando la propiedad [[yii\validators\Validator::isEmpty]]
|
||||
con una función PHP invocable. Por ejemplo,
|
||||
|
||||
```php
|
||||
['agree', 'required', 'isEmpty' => function ($value) {
|
||||
return empty($value);
|
||||
}]
|
||||
```
|
||||
|
||||
> Note: La mayoría de los validadores no manejan entradas vacías si su propiedad [[yii\validators\Validator::skipOnEmpty]] toma
|
||||
el valor por defecto true. Estas serán simplemente salteadas durante la validación si sus atributos asociados reciben una entrada vacía.
|
||||
Entre los [validadores del framework](tutorial-core-validators.md), sólo `captcha`, `default`, `filter`,
|
||||
`required`, y `trim` manejarán entradas vacías.
|
||||
|
||||
|
||||
## Validación Ad Hoc <span id="ad-hoc-validation"></span>
|
||||
|
||||
A veces necesitas realizar *validación ad hoc* para valores que no están ligados a ningún modelo.
|
||||
|
||||
Si sólo necesitas realizar un tipo de validación (por ej: validar direcciones de email), podrías llamar
|
||||
al método [[yii\validators\Validator::validate()|validate()]] de los validadores deseados, como a continuación:
|
||||
|
||||
```php
|
||||
$email = 'test@example.com';
|
||||
$validator = new yii\validators\EmailValidator();
|
||||
|
||||
if ($validator->validate($email, $error)) {
|
||||
echo 'Email válido.';
|
||||
} else {
|
||||
echo $error;
|
||||
}
|
||||
```
|
||||
|
||||
> Note: No todos los validadores soportan este tipo de validación. Un ejemplo es el validador del framework [unique](tutorial-core-validators.md#unique),
|
||||
que está diseñado para trabajar sólo con un modelo.
|
||||
|
||||
Si necesitas realizar varias validaciones contro varios valores, puedes utilizar [[yii\base\DynamicModel]],
|
||||
que soporta declarar tanto los atributos como las reglas sobre la marcha. Su uso es como a continuación:
|
||||
|
||||
```php
|
||||
public function actionSearch($name, $email)
|
||||
{
|
||||
$model = DynamicModel::validateData(compact('name', 'email'), [
|
||||
[['name', 'email'], 'string', 'max' => 128],
|
||||
['email', 'email'],
|
||||
]);
|
||||
|
||||
if ($model->hasErrors()) {
|
||||
// validación fallida
|
||||
} else {
|
||||
// validación exitosa
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
El método [[yii\base\DynamicModel::validateData()]] crea una instancia de `DynamicModel`, define los atributos
|
||||
utilizando los datos provistos (`name` e `email` en este ejemplo), y entonces llama a [[yii\base\Model::validate()]]
|
||||
con las reglas provistas.
|
||||
|
||||
Alternativamente, puedes utilizar la sintaxis más "clásica" para realizar la validación ad hoc:
|
||||
|
||||
```php
|
||||
public function actionSearch($name, $email)
|
||||
{
|
||||
$model = new DynamicModel(compact('name', 'email'));
|
||||
$model->addRule(['name', 'email'], 'string', ['max' => 128])
|
||||
->addRule('email', 'email')
|
||||
->validate();
|
||||
|
||||
if ($model->hasErrors()) {
|
||||
// validación fallida
|
||||
} else {
|
||||
// validación exitosa
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Después de la validación, puedes verificar si la validación tuvo éxito o no llamando al
|
||||
método [[yii\base\DynamicModel::hasErrors()|hasErrors()]], obteniendo así los errores de validación de la
|
||||
propiedad [[yii\base\DynamicModel::errors|errors]], como haces con un modelo normal.
|
||||
Puedes también acceder a los atributos dinámicos definidos a través de la instancia del modelo, por ej.,
|
||||
`$model->name` y `$model->email`.
|
||||
|
||||
|
||||
## Crear Validadores <span id="creating-validators"></span>
|
||||
|
||||
Además de los [validadores del framework](tutorial-core-validators.md) incluidos en los lanzamientos de Yii, puedes también
|
||||
crear tus propios validadores. Puedes crear validadores en línea o validadores independientes.
|
||||
|
||||
|
||||
### Validadores en Línea <span id="inline-validators"></span>
|
||||
|
||||
Un validador en línea es uno definido en términos del método de un modelo o una función anónima. La firma
|
||||
del método/función es:
|
||||
|
||||
```php
|
||||
/**
|
||||
* @param string $attribute el atributo siendo validado actualmente
|
||||
* @param mixed $params el valor de los "parámetros" dados en la regla
|
||||
*/
|
||||
function ($attribute, $params)
|
||||
```
|
||||
|
||||
Si falla la validación de un atributo, el método/función debería llamar a [[yii\base\Model::addError()]] para guardar
|
||||
el mensaje de error en el modelo de manera que pueda ser recuperado más tarde y presentado a los usuarios finales.
|
||||
|
||||
Debajo hay algunos ejemplos:
|
||||
|
||||
```php
|
||||
use yii\base\Model;
|
||||
|
||||
class MyForm extends Model
|
||||
{
|
||||
public $country;
|
||||
public $token;
|
||||
|
||||
public function rules()
|
||||
{
|
||||
return [
|
||||
// un validador en línea definido como el método del modelo validateCountry()
|
||||
['country', 'validateCountry'],
|
||||
|
||||
// un validador en línea definido como una función anónima
|
||||
['token', function ($attribute, $params) {
|
||||
if (!ctype_alnum($this->$attribute)) {
|
||||
$this->addError($attribute, 'El token debe contener letras y dígitos.');
|
||||
}
|
||||
}],
|
||||
];
|
||||
}
|
||||
|
||||
public function validateCountry($attribute, $params)
|
||||
{
|
||||
if (!in_array($this->$attribute, ['USA', 'Web'])) {
|
||||
$this->addError($attribute, 'El país debe ser "USA" o "Web".');
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
> Note: Por defecto, los validadores en línea no serán aplicados si sus atributos asociados reciben entradas vacías
|
||||
o si alguna de sus reglas de validación ya falló. Si quieres asegurarte de que una regla siempre sea aplicada,
|
||||
puedes configurar las reglas [[yii\validators\Validator::skipOnEmpty|skipOnEmpty]] y/o [[yii\validators\Validator::skipOnError|skipOnError]]
|
||||
como false en las declaraciones de las reglas. Por ejemplo:
|
||||
>
|
||||
> ```php
|
||||
> [
|
||||
> ['country', 'validateCountry', 'skipOnEmpty' => false, 'skipOnError' => false],
|
||||
> ]
|
||||
> ```
|
||||
|
||||
|
||||
### Validadores Independientes <span id="standalone-validators"></span>
|
||||
|
||||
Un validador independiente es una clase que extiende de [[yii\validators\Validator]] o sus sub clases. Puedes implementar
|
||||
su lógica de validación sobrescribiendo el método [[yii\validators\Validator::validateAttribute()]]. Si falla la validación
|
||||
de un atributo, llama a [[yii\base\Model::addError()]] para guardar el mensaje de error en el modelo, tal como haces
|
||||
con los [validadores en línea](#inline-validators).
|
||||
|
||||
|
||||
Por ejemplo, el validador en línea de arriba podría ser movida a una nueva clase [[components/validators/CountryValidator]].
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
|
||||
use yii\validators\Validator;
|
||||
|
||||
class CountryValidator extends Validator
|
||||
{
|
||||
public function validateAttribute($model, $attribute)
|
||||
{
|
||||
if (!in_array($model->$attribute, ['USA', 'Web'])) {
|
||||
$this->addError($model, $attribute, 'El país debe ser "USA" o "Web".');
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Si quieres que tu validador soporte la validación de un valor sin modelo, deberías también sobrescribir
|
||||
el método[[yii\validators\Validator::validate()]]. Puedes también sobrescribir [[yii\validators\Validator::validateValue()]]
|
||||
en vez de `validateAttribute()` y `validate()` porque por defecto los últimos dos métodos son implementados
|
||||
llamando a `validateValue()`.
|
||||
|
||||
Debajo hay un ejemplo de cómo podrías utilizar la clase del validador de arriba dentro de tu modelo.
|
||||
|
||||
```php
|
||||
namespace app\models;
|
||||
|
||||
use Yii;
|
||||
use yii\base\Model;
|
||||
use app\components\validators\CountryValidator;
|
||||
|
||||
class EntryForm extends Model
|
||||
{
|
||||
public $name;
|
||||
public $email;
|
||||
public $country;
|
||||
|
||||
public function rules()
|
||||
{
|
||||
return [
|
||||
[['name', 'email'], 'required'],
|
||||
['country', CountryValidator::className()],
|
||||
['email', 'email'],
|
||||
];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
## Validación del Lado del Cliente <span id="client-side-validation"></span>
|
||||
|
||||
La validación del lado del cliente basada en JavaScript es deseable cuando la entrada del usuario proviene de formularios HTML, dado que
|
||||
permite a los usuarios encontrar errores más rápido y por lo tanto provee una mejor experiencia. Puedes utilizar o implementar
|
||||
un validador que soporte validación del lado del cliente *en adición a* validación del lado del servidor.
|
||||
|
||||
> Info: Si bien la validación del lado del cliente es deseable, no es una necesidad. Su principal propósito es proveer al usuario una mejor
|
||||
experiencia. Al igual que datos de entrada que vienen del los usuarios finales, nunca deberías confiar en la validación del lado del cliente. Por esta razón,
|
||||
deberías realizar siempre la validación del lado del servidor llamando a [[yii\base\Model::validate()]], como
|
||||
se describió en las subsecciones previas.
|
||||
|
||||
|
||||
### Utilizar Validación del Lado del Cliente <span id="using-client-side-validation"></span>
|
||||
|
||||
Varios [validadores del framework](tutorial-core-validators.md) incluyen validación del lado del cliente. Todo lo que necesitas hacer
|
||||
es solamente utilizar [[yii\widgets\ActiveForm]] para construir tus formularios HTML. Por ejemplo, `LoginForm` mostrado abajo declara dos
|
||||
reglas: una utiliza el validador del framework [required](tutorial-core-validators.md#required), el cual es soportado tanto en
|
||||
lado del cliente como del servidor; y el otro usa el validador en línea `validatePassword`, que es sólo soportado de lado
|
||||
del servidor.
|
||||
|
||||
```php
|
||||
namespace app\models;
|
||||
|
||||
use yii\base\Model;
|
||||
use app\models\User;
|
||||
|
||||
class LoginForm extends Model
|
||||
{
|
||||
public $username;
|
||||
public $password;
|
||||
|
||||
public function rules()
|
||||
{
|
||||
return [
|
||||
// username y password son ambos requeridos
|
||||
[['username', 'password'], 'required'],
|
||||
|
||||
// password es validado por validatePassword()
|
||||
['password', 'validatePassword'],
|
||||
];
|
||||
}
|
||||
|
||||
public function validatePassword()
|
||||
{
|
||||
$user = User::findByUsername($this->username);
|
||||
|
||||
if (!$user || !$user->validatePassword($this->password)) {
|
||||
$this->addError('password', 'Username o password incorrecto.');
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
El formulario HTML creado en el siguiente código contiene dos campos de entrada: `username` y `password`.
|
||||
Si envias el formulario sin escribir nada, encontrarás que los mensajes de error requiriendo que
|
||||
escribas algo aparecen sin que haya comunicación alguna con el servidor.
|
||||
|
||||
```php
|
||||
<?php $form = yii\widgets\ActiveForm::begin(); ?>
|
||||
<?= $form->field($model, 'username') ?>
|
||||
<?= $form->field($model, 'password')->passwordInput() ?>
|
||||
<?= Html::submitButton('Login') ?>
|
||||
<?php yii\widgets\ActiveForm::end(); ?>
|
||||
```
|
||||
|
||||
Detrás de escena, [[yii\widgets\ActiveForm]] leerá las reglas de validación declaradas en el modelo
|
||||
y generará el código JavaScript apropiado para los validadores que soportan validación del lado del cliente. Cuando un usuario
|
||||
cambia el valor de un campo o envia el formulario, se lanzará la validación JavaScript del lado del cliente.
|
||||
|
||||
Si quieres deshabilitar la validación del lado del cliente completamente, puedes configurar
|
||||
la propiedad [[yii\widgets\ActiveForm::enableClientValidation]] como false. También puedes deshabilitar la validación
|
||||
del lado del cliente de campos individuales configurando su propiedad [[yii\widgets\ActiveField::enableClientValidation]]
|
||||
como false. Cuando `enableClientValidation` es configurado tanto a nivel de campo como a nivel de formulario,
|
||||
tendrá prioridad la primera.
|
||||
|
||||
### Implementar Validación del Lado del Cliente <span id="implementing-client-side-validation"></span>
|
||||
|
||||
|
||||
Para crear validadores que soportan validación del lado del cliente, debes implementar
|
||||
el método [[yii\validators\Validator::clientValidateAttribute()]], que devuelve una pieza de código JavaScript
|
||||
que realiza dicha validación. Dentro del código JavaScript, puedes utilizar las siguientes
|
||||
variables predefinidas:
|
||||
|
||||
- `attribute`: el nombre del atributo siendo validado.
|
||||
- `value`: el valor siendo validado.
|
||||
- `messages`: un array utilizado para contener los mensajes de error de validación para el atributo.
|
||||
- `deferred`: un array con objetos diferidos puede ser insertado (explicado en la subsección siguiente).
|
||||
|
||||
En el siguiente ejemplo, creamos un `StatusValidator` que valida si la entrada es un status válido
|
||||
contra datos de status existentes. El validador soporta tato tanto validación del lado del servidor como del lado del cliente.
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
|
||||
use yii\validators\Validator;
|
||||
use app\models\Status;
|
||||
|
||||
class StatusValidator extends Validator
|
||||
{
|
||||
public function init()
|
||||
{
|
||||
parent::init();
|
||||
$this->message = 'Entrada de Status Inválida.';
|
||||
}
|
||||
|
||||
public function validateAttribute($model, $attribute)
|
||||
{
|
||||
$value = $model->$attribute;
|
||||
if (!Status::find()->where(['id' => $value])->exists()) {
|
||||
$model->addError($attribute, $this->message);
|
||||
}
|
||||
}
|
||||
|
||||
public function clientValidateAttribute($model, $attribute, $view)
|
||||
{
|
||||
$statuses = json_encode(Status::find()->select('id')->asArray()->column());
|
||||
$message = json_encode($this->message, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
|
||||
return <<<JS
|
||||
if ($.inArray(value, $statuses) === -1) {
|
||||
messages.push($message);
|
||||
}
|
||||
JS;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
> Tip: El código de arriba muestra principalmente cómo soportar validación del lado del cliente. En la práctica,
|
||||
> puedes utilizar el validador del framework [in](tutorial-core-validators.md#in) para alcanzar el mismo objetivo. Puedes
|
||||
> escribir la regla de validación como a como a continuación:
|
||||
>
|
||||
> ```php
|
||||
> [
|
||||
> ['status', 'in', 'range' => Status::find()->select('id')->asArray()->column()],
|
||||
> ]
|
||||
> ```
|
||||
|
||||
> Tip: Si necesitas trabajar con validación del lado del cliente manualmente, por ejemplo, agregar campos dinámicamente o realizar alguna lógica de UI,
|
||||
> consulta [Trabajar con ActiveForm vía JavaScript](https://github.com/samdark/yii2-cookbook/blob/master/book/forms-activeform-js.md)
|
||||
> en el Yii 2.0 Cookbook.
|
||||
|
||||
### Validación Diferida <span id="deferred-validation"></span>
|
||||
|
||||
Si necesitas realizar validación del lado del cliente asincrónica, puedes crear [Objetos Diferidos](http://api.jquery.com/category/deferred-object/).
|
||||
Por ejemplo, para realizar validación AJAX personalizada, puedes utilizar el siguiente código:
|
||||
|
||||
```php
|
||||
public function clientValidateAttribute($model, $attribute, $view)
|
||||
{
|
||||
return <<<JS
|
||||
deferred.push($.get("/check", {value: value}).done(function(data) {
|
||||
if ('' !== data) {
|
||||
messages.push(data);
|
||||
}
|
||||
}));
|
||||
JS;
|
||||
}
|
||||
```
|
||||
|
||||
Arriba, la variable `deferred` es provista por Yii, y es un array de Objetos Diferidos. El método `$.get()`
|
||||
de jQuery crea un Objeto Diferido, el cual es insertado en el array `deferred`.
|
||||
|
||||
Puedes también crear un Objeto Diferito explícitamente y llamar a su método `resolve()` cuando la llamada asincrónica
|
||||
tiene lugar. El siguiente ejemplo muestra cómo validar las dimensiones de un archivo de imagen del lado del cliente.
|
||||
|
||||
```php
|
||||
public function clientValidateAttribute($model, $attribute, $view)
|
||||
{
|
||||
return <<<JS
|
||||
var def = $.Deferred();
|
||||
var img = new Image();
|
||||
img.onload = function() {
|
||||
if (this.width > 150) {
|
||||
messages.push('Imagen demasiado ancha!!');
|
||||
}
|
||||
def.resolve();
|
||||
}
|
||||
var reader = new FileReader();
|
||||
reader.onloadend = function() {
|
||||
img.src = reader.result;
|
||||
}
|
||||
reader.readAsDataURL(file);
|
||||
|
||||
deferred.push(def);
|
||||
JS;
|
||||
}
|
||||
```
|
||||
|
||||
> Note: El método `resolve()` debe ser llamado después de que el atributo ha sido validado. De otra manera la validación
|
||||
principal del formulario no será completada.
|
||||
|
||||
Por simplicidad, el array `deferred` está equipado con un método de atajo, `add()`, que automáticamente crea un
|
||||
Objeto Diferido y lo agrega al array `deferred`. Utilizando este método, puedes simplificar el ejemplo de arriba de esta manera,
|
||||
|
||||
```php
|
||||
public function clientValidateAttribute($model, $attribute, $view)
|
||||
{
|
||||
return <<<JS
|
||||
deferred.add(function(def) {
|
||||
var img = new Image();
|
||||
img.onload = function() {
|
||||
if (this.width > 150) {
|
||||
messages.push('Imagen demasiado ancha!!');
|
||||
}
|
||||
def.resolve();
|
||||
}
|
||||
var reader = new FileReader();
|
||||
reader.onloadend = function() {
|
||||
img.src = reader.result;
|
||||
}
|
||||
reader.readAsDataURL(file);
|
||||
});
|
||||
JS;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### Validación AJAX <span id="ajax-validation"></span>
|
||||
|
||||
Algunas validaciones sólo pueden realizarse del lado del servidor, debido a que sólo el servidor tiene la información necesaria.
|
||||
Por ejemplo, para validar si un nombre de usuario es único o no, es necesario revisar la tabla de usuarios del lado del servidor.
|
||||
Puedes utilizar validación basada en AJAX en este caso. Esta lanzará una petición AJAX de fondo para validar
|
||||
la entrada mientras se mantiene la misma experiencia de usuario como en una validación del lado del cliente regular.
|
||||
|
||||
Para habilitar la validación AJAX individualmente un campo de entrada, configura la propiedad [[yii\widgets\ActiveField::enableAjaxValidation|enableAjaxValidation]]
|
||||
de ese campo como true y especifica un único `id` de formulario:
|
||||
|
||||
```php
|
||||
use yii\widgets\ActiveForm;
|
||||
|
||||
$form = ActiveForm::begin([
|
||||
'id' => 'registration-form',
|
||||
]);
|
||||
|
||||
echo $form->field($model, 'username', ['enableAjaxValidation' => true]);
|
||||
|
||||
// ...
|
||||
|
||||
ActiveForm::end();
|
||||
```
|
||||
|
||||
Para habiliar la validación AJAX en el formulario entero, configura [[yii\widgets\ActiveForm::enableAjaxValidation|enableAjaxValidation]]
|
||||
como true a nivel del formulario:
|
||||
|
||||
```php
|
||||
$form = ActiveForm::begin([
|
||||
'id' => 'contact-form',
|
||||
'enableAjaxValidation' => true,
|
||||
]);
|
||||
```
|
||||
|
||||
> Note: Cuando la propiedad `enableAjaxValidation` es configurada tanto a nivel de campo como a nivel de formulario,
|
||||
la primera tendrá prioridad.
|
||||
|
||||
Necesitas también preparar el servidor para que pueda manejar las peticiones AJAX.
|
||||
Esto puede alcanzarse con una porción de código como la siguiente en las acciones del controlador:
|
||||
|
||||
```php
|
||||
if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post())) {
|
||||
Yii::$app->response->format = Response::FORMAT_JSON;
|
||||
return ActiveForm::validate($model);
|
||||
}
|
||||
```
|
||||
|
||||
El código de arriba chequeará si la petición actual es AJAX o no. Si lo es, responderá
|
||||
esta petición ejecutando la validación y devolviendo los errores en formato JSON.
|
||||
|
||||
> Info: Puedes también utilizar [Validación Diferida](#deferred-validation) para realizar validación AJAX.
|
||||
De todos modos, la característica de validación AJAX descrita aquí es más sistemática y requiere menos esfuerzo de escritura de código.
|
||||
|
||||
Cuando tanto `enableClientValidation` como `enableAjaxValidation` son definidas como true, la petición de validación AJAX será lanzada
|
||||
sólo después de una validación del lado del cliente exitosa.
|
||||
@ -1,5 +1,5 @@
|
||||
Actualizando desde Yii 1.1
|
||||
==========================
|
||||
Actualizar desde Yii 1.1
|
||||
========================
|
||||
|
||||
Existen muchas diferencias entre las versiones 1.1 y 2.0 de Yii ya que el framework fue completamente reescrito
|
||||
en su segunda versión.
|
||||
@ -18,7 +18,8 @@ Instalación
|
||||
Yii 2.0 adopta íntegramente [Composer](https://getcomposer.org/), el administrador de paquetes de facto de PHP.
|
||||
Tanto la instalación del núcleo del framework como las extensiones se manejan a través de Composer. Por favor consulta
|
||||
la sección [Comenzando con la Aplicación Básica](start-installation.md) para aprender a instalar Yii 2.0. Si quieres crear extensiones
|
||||
o transformar extensiones de Yii 1.1 para que sean compatibles con Yii 2.0, consulta la sección [Creando Extensiones](structure-extensions.md#creating-extensions) de la guía.
|
||||
o transformar extensiones de Yii 1.1 para que sean compatibles con Yii 2.0, consulta
|
||||
la sección [Creando Extensiones](structure-extensions.md#creating-extensions) de la guía.
|
||||
|
||||
|
||||
Requerimientos de PHP
|
||||
@ -107,7 +108,7 @@ $object = Yii::createObject([
|
||||
], [$param1, $param2]);
|
||||
```
|
||||
|
||||
Se puede encontrar más detalles acerca del tema en la sección [Configuración de objetos](concept-configurations.md).
|
||||
Se puede encontrar más detalles acerca del tema en la sección [Configuración](concept-configurations.md).
|
||||
|
||||
|
||||
Eventos
|
||||
@ -142,7 +143,7 @@ están soportados en la mayor parte del núcleo. Por ejemplo, [[yii\caching\File
|
||||
una ruta de directorios normal como un alias.
|
||||
|
||||
Un alias está estrechamente relacionado con un namespace de la clase. Se recomienda definir un alias
|
||||
por cada namespace raíz, y así poder utilizar el autolader de Yii sin otra configuración.
|
||||
por cada namespace raíz, y así poder utilizar el autoloader de Yii sin otra configuración.
|
||||
Por ejemplo, debido a que `@yii` se refiere al directorio de instalación, una clase
|
||||
como `yii\web\Request` puede ser auto-cargada. Si estás utilizando una librería de terceros,
|
||||
como Zend Framework, puedes definir un alias `@Zend` que se refiera al directorio de instalación
|
||||
@ -155,15 +156,12 @@ Vistas
|
||||
------
|
||||
|
||||
El cambio más significativo con respecto a las vistas en Yii 2 es que la variable especial `$this` dentro de una vista
|
||||
ya no se refiere al controlador o widget actual.
|
||||
En vez de eso, `$this` ahora se refiere al objeto de la *vista*, un concepto nuevo introducido en Yii 2.0.
|
||||
El objeto *vista* es del tipo [[yii\web\View]], que representa la parte de las vistas en el patrón MVC. Si
|
||||
quieres acceder al controlador o al widget correspondiente desde la propia vista,
|
||||
puedes utilizar `$this->context`.
|
||||
ya no se refiere al controlador o widget actual. En vez de eso, `$this` ahora se refiere al objeto de la *vista*, un concepto nuevo
|
||||
introducido en Yii 2.0. El objeto *vista* es del tipo [[yii\web\View]], que representa la parte de las vistas
|
||||
en el patrón MVC. Si quieres acceder al controlador o al widget correspondiente desde la propia vista, puedes utilizar `$this->context`.
|
||||
|
||||
Para renderizar una vista parcial (partial) dentro de otra vista, se utiliza `$this->render()`, no `$this->renderPartial()`.
|
||||
La llamada a `render` además tiene que ser mostrada explícitamente a través de `echo`, ya que el método `render()`
|
||||
devuelve el resultado de la renderización en vez de mostrarlo directamente. Por ejemplo:
|
||||
Para renderizar una vista parcial (partial) dentro de otra vista, se utiliza `$this->render()`, no `$this->renderPartial()`. La llamada a `render` además tiene que ser mostrada explícitamente a través de `echo`,
|
||||
ya que el método `render()` devuelve el resultado de la renderización en vez de mostrarlo directamente. Por ejemplo:
|
||||
|
||||
```php
|
||||
echo $this->render('_item', ['item' => $item]);
|
||||
@ -172,7 +170,8 @@ echo $this->render('_item', ['item' => $item]);
|
||||
Además de utilizar PHP como el lenguaje principal de plantillas (templates), Yii 2.0 está también equipado con soporte
|
||||
oficial de otros dos motores de plantillas populares: Smarty y Twig. El motor de plantillas de Prado ya no está soportado.
|
||||
Para utilizar esos motores, necesitas configurar el componente `view` de la aplicación, definiendo la propiedad [[yii\base\View::$renderers|View::$renderers]].
|
||||
Por favor consulta la sección [Motores de Plantillas](tutorial-template-engines.md) para más detalles.
|
||||
Por favor consulta la sección [Motores de Plantillas](tutorial-template-engines.md)
|
||||
para más detalles.
|
||||
|
||||
|
||||
Modelos
|
||||
@ -431,7 +430,7 @@ class Customer extends \yii\db\ActiveRecord
|
||||
```
|
||||
|
||||
Ahora puedes utilizar `$customer->orders` para acceder a las órdenes de la tabla relacionada. También puedes utilizar el siguiente
|
||||
código para realizar una consulta relacional 'al-vuelo' con una condición personalizada:
|
||||
código para realizar una consulta relacional 'sobre la marcha' con una condición personalizada:
|
||||
|
||||
```php
|
||||
$orders = $customer->getOrders()->andWhere('status=1')->all();
|
||||
@ -504,9 +503,10 @@ User e IdentityInterface
|
||||
|
||||
La clase `CWebUser` de 1.1 es reemplazada por [[yii\web\User]], y la clase `CUserIdentity` ha dejado de existir.
|
||||
En cambio, ahora debes implementar [[yii\web\IdentityInterface]] el cual es mucho más directo de usar.
|
||||
La plantilla de Aplicación Avanzada provee un ejemplo así.
|
||||
El template de proyecto avanzado provee un ejemplo así.
|
||||
|
||||
Consulta las secciones [Autenticación](security-authentication.md), [Autorización](security-authorization.md), y [Template de Proyecto Avanzado](https://github.com/yiisoft/yii2-app-advanced/blob/master/docs/guide-es/README.md) para más detalles.
|
||||
|
||||
Consulta las secciones [Autenticación](security-authentication.md), [Autorización](security-authorization.md), y [Plantilla de Aplicación Avanzada](tutorial-advanced-app.md) para más detalles.
|
||||
|
||||
|
||||
Manejo de URLs
|
||||
@ -526,8 +526,14 @@ En 1.1, tendrías que haber creado dos reglas diferentes para obtener el mismo r
|
||||
|
||||
Por favor, consulta la sección [Documentación del Manejo de URLs](runtime-routing.md) para más detalles.
|
||||
|
||||
Utilizando Yii 1.1 y 2.x juntos
|
||||
-------------------------------
|
||||
Un cambio importante en la convención de nombres para rutas es que los nombres en CamelCase de controladores
|
||||
y acciones ahora son convertidos a minúsculas y cada palabra separada por un guión, por ejemplo el id del controlador
|
||||
`CamelCaseController` será `camel-case`.
|
||||
Consulta la sección acerca de [IDs de controladores](structure-controllers.md#controller-ids) y [IDs de acciones](structure-controllers.md#action-ids) para más detalles.
|
||||
|
||||
|
||||
Utilizar Yii 1.1 y 2.x juntos
|
||||
-----------------------------
|
||||
|
||||
Si tienes código en Yii 1.1 que quisieras utilizar junto con Yii 2.0, por favor consulta
|
||||
la sección [Utilizando Yii 1.1 y 2.0 juntos](tutorial-yii-integration.md).
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
Validadores del núcleo
|
||||
======================
|
||||
Validadores del framework
|
||||
=========================
|
||||
|
||||
Yii provee en el núcleo un conjunto de validadores de uso común, que se pueden encontrar principalmente bajo el espacio de nombres (namespace) `yii\validators`.
|
||||
Yii provee en su núcleo un conjunto de validadores de uso común, que se pueden encontrar principalmente bajo el espacio de nombres (namespace) `yii\validators`.
|
||||
En vez de utilizar interminables nombres de clases para los validadores, puedes usar *alias* para especificar el uso de esos validadores del núcleo. Por ejemplo, puedes usar el alias `required` para referirte a la clase [[yii\validators\RequiredValidator]] :
|
||||
|
||||
```php
|
||||
|
||||
Reference in New Issue
Block a user