Se admiten las siguientes opciones para Zend_Validate_Alnum:

Un ejemplo básico es el siguiente:

$validator = new Zend_Validate_Alnum();
if ($validator->isValid('Abcd12')) {
    // value contains only allowed chars
} else {
    // false
}

Por defecto los espacios en blanco no se aceptan porque no forman parte del alfabeto. Aun así, hay una forma de aceptarlos como entrada. Esto permite validar oraciones o frases completas.

Para permitir el uso de espacios en blanco debe indicar la opción allowWhiteSpace. Esto se puede hacer al crear una instancia del validador, o posteriormente mediante setAllowWhiteSpace(). Para obtener el estado actual puede usar getAllowWhiteSpace().

$validator = new Zend_Validate_Alnum(array('allowWhiteSpace' => true));
if ($validator->isValid('Abcd and 12')) {
    // value contains only allowed chars
} else {
    // false
}

Al usar Zend_Validate_Alnum, el idioma que el usuario configure en su navegador se utilizará para establecer los caracteres permitidos. Esto significa que cuando su usuario configura de para alemán, también puede introducir caracteres como ä, ö y ü además de los caracteres del alfabeto inglés.

Qué caracteres están permitidos depende completamente del idioma utilizado, ya que cada idioma define su propio conjunto de caracteres.

En realidad hay 3 idiomas que no se aceptan en su propia escritura. Estos idiomas son coreano, japonés y chino, ya que estos idiomas utilizan un alfabeto en el que un solo carácter se construye usando múltiples caracteres.

En caso de que utilice estos idiomas, la entrada solo se validará usando el alfabeto inglés.

Se admiten las siguientes opciones para Zend_Validate_Alpha:

Un ejemplo básico es el siguiente:

$validator = new Zend_Validate_Alpha();
if ($validator->isValid('Abcd')) {
    // value contains only allowed chars
} else {
    // false
}

Por defecto los espacios en blanco no se aceptan porque no forman parte del alfabeto. Aun así, hay una forma de aceptarlos como entrada. Esto permite validar oraciones o frases completas.

Para permitir el uso de espacios en blanco debe indicar la opción allowWhiteSpace. Esto se puede hacer al crear una instancia del validador, o posteriormente mediante setAllowWhiteSpace(). Para obtener el estado actual puede usar getAllowWhiteSpace().

$validator = new Zend_Validate_Alpha(array('allowWhiteSpace' => true));
if ($validator->isValid('Abcd and efg')) {
    // value contains only allowed chars
} else {
    // false
}

Al usar Zend_Validate_Alpha, el idioma que el usuario configure en su navegador se utilizará para establecer los caracteres permitidos. Esto significa que cuando su usuario configura de para alemán, también puede introducir caracteres como ä, ö y ü además de los caracteres del alfabeto inglés.

Qué caracteres están permitidos depende completamente del idioma utilizado, ya que cada idioma define su propio conjunto de caracteres.

En realidad hay 3 idiomas que no se aceptan en su propia escritura. Estos idiomas son coreano, japonés y chino, ya que estos idiomas utilizan un alfabeto en el que un solo carácter se construye usando múltiples caracteres.

En caso de que utilice estos idiomas, la entrada solo se validará usando el alfabeto inglés.

Se admiten las siguientes opciones para Zend_Validate_Barcode:

Para validar si una cadena determinada es un código de barras solo necesita conocer su tipo. Vea el siguiente ejemplo para un código de barras EAN13:

$valid = new Zend_Validate_Barcode('EAN13');
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Algunos códigos de barras se pueden proporcionar con un checksum opcional. Estos códigos de barras serían válidos incluso sin checksum. Aun así, cuando proporciona un checksum, también debería validarlo. Por defecto, estos tipos de código de barras no realizan validación de checksum. Usando la opción checksum puede definir si el checksum se validará o se ignorará.

$valid = new Zend_Validate_Barcode(array(
    'adapter'  => 'EAN13',
    'checksum' => false,
));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

	Seguridad reducida al deshabilitar la validación de checksum
	Al desactivar la validación de checksum también reducirá la seguridad de los códigos de barras usados. Además debe tener en cuenta que también puede desactivar la validación de checksum para aquellos tipos de código de barras que deben contener un valor de checksum. Los códigos de barras que no serían válidos podrían entonces devolverse como válidos aunque no lo sean.

Puede escribir validadores de código de barras personalizados para usar con Zend_Validate_Barcode; esto suele ser necesario cuando se trabaja con tipos de código de barras propietarios. Para escribir su propio validador de código de barras, necesita la siguiente información.

Su validador de código de barras personalizado debe extender Zend_Validate_Barcode_AdapterAbstract o implementar Zend_Validate_Barcode_AdapterInterface.

Como ejemplo, creemos un validador que espera un número par de caracteres que incluyan todos los dígitos y las letras 'ABCDE', y que requiere un checksum.

class My_Barcode_MyBar extends Zend_Validate_Barcode_AdapterAbstract
{
    protected $_length     = 'even';
    protected $_characters = '0123456789ABCDE';
    protected $_checksum   = '_mod66';

    protected function _mod66($barcode)
    {
        // do some validations and return a boolean
    }
}

$valid = new Zend_Validate_Barcode('My_Barcode_MyBar');
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Se admiten las siguientes opciones para Zend_Validate_Between:

Por defecto este validador comprueba si un valor está entre min y max, donde ambos valores límite están permitidos como valor.

$valid  = new Zend_Validate_Between(array('min' => 0, 'max' => 10));
$value  = 10;
$result = $valid->isValid($value);
// returns true

En el ejemplo anterior el resultado es TRUE debido a que por defecto la búsqueda incluye los valores límite. Esto significa en nuestro caso que cualquier valor de '0' a '10' está permitido. Y valores como '-1' y '11' devolverán FALSE.

A veces es útil validar un valor excluyendo los valores límite. Vea el siguiente ejemplo:

$valid  = new Zend_Validate_Between(
    array(
        'min' => 0,
        'max' => 10,
        'inclusive' => false
    )
);
$value  = 10;
$result = $valid->isValid($value);
// returns false

El ejemplo es casi igual a nuestro primer ejemplo, pero excluimos el valor límite. Ahora los valores '0' y '10' ya no están permitidos y devolverán FALSE.

Se admiten las siguientes opciones para Zend_Validate_Callback:

El caso de uso más simple es tener una sola función y usarla como callback. Supongamos que tenemos la siguiente función.

function myMethod($value)
{
    // some validation
    return true;
}

Para usarla dentro de Zend_Validate_Callback solo tiene que llamarla de esta manera:

$valid = new Zend_Validate_Callback('myMethod');
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

PHP 5.3 introduce las closures, que son básicamente funciones autocontenidas o anónimas. PHP considera las closures otra forma de callback, y, como tal, se pueden usar con Zend_Validate_Callback. Por ejemplo:

$valid = new Zend_Validate_Callback(function($value){
    // some validation
    return true;
});

if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Por supuesto también es posible usar un método de clase como callback. Supongamos que tenemos el siguiente método de clase:

class MyClass
{
    public function myMethod($value)
    {
        // some validation
        return true;
    }
}

La definición del callback es en este caso casi la misma. Solo tiene que crear una instancia de la clase antes del método y crear un array que describa el callback:

$object = new MyClass;
$valid = new Zend_Validate_Callback(array($object, 'myMethod'));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

También puede definir un método estático como callback. Considere la siguiente definición de clase y uso del validador:

class MyClass
{
    public static function test($value)
    {
        // some validation
        return true;
    }
}

$valid = new Zend_Validate_Callback(array('MyClass', 'test'));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Finalmente, si está usando PHP 5.3, puede definir el método mágico __invoke() en su clase. Si lo hace, simplemente proporcionar una instancia de la clase como callback también funcionará:

class MyClass
{
    public function __invoke($value)
    {
        // some validation
        return true;
    }
}

$object = new MyClass();
$valid = new Zend_Validate_Callback($object);
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Zend_Validate_Callback también permite el uso de opciones que se proporcionan como argumentos adicionales al callback.

Considere la siguiente definición de clase y método:

class MyClass
{
    function myMethod($value, $option)
    {
        // some validation
        return true;
    }
}

Hay dos formas de informar al validador sobre opciones adicionales: pasarlas en el constructor, o pasarlas al método setOptions().

Para pasarlas al constructor, necesitaría pasar un array que contenga dos claves, "callback" y "options":

$valid = new Zend_Validate_Callback(array(
    'callback' => array('MyClass', 'myMethod'),
    'options'  => $option,
));

if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

De lo contrario, puede pasarlas al validador después de la instanciación:

$valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
$valid->setOptions($option);

if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Cuando se dan valores adicionales a isValid(), estos valores se añadirán inmediatamente después de $value.

$valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
$valid->setOptions($option);

if ($valid->isValid($input, $additional)) {
    // input appears to be valid
} else {
    // input is invalid
}

Al hacer la llamada al callback, el valor que se va a validar siempre se pasará como primer argumento al callback, seguido de todos los demás valores dados a isValid(); todas las demás opciones lo seguirán. La cantidad y el tipo de opciones que se pueden usar no está limitado.

Se admiten las siguientes opciones para Zend_Validate_CreditCard:

Hay varias entidades de tarjetas de crédito que pueden validarse con Zend_Validate_CreditCard. Por defecto, se aceptarán todas las entidades conocidas. Vea el siguiente ejemplo:

$valid = new Zend_Validate_CreditCard();
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

El ejemplo anterior validaría contra todas las entidades de tarjetas de crédito conocidas.

A veces es necesario aceptar solo entidades de tarjetas de crédito definidas en lugar de todas; por ejemplo, cuando tiene una tienda en línea que solo acepta tarjetas Visa y American Express. Zend_Validate_CreditCard le permite hacer exactamente esto limitándolo exactamente a estas entidades.

Para usar una limitación puede proporcionar entidades específicas en la inicialización, o posteriormente mediante setType(). Cada uno puede tomar varios argumentos.

Puede proporcionar una sola entidad:

$valid = new Zend_Validate_CreditCard(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS
);

Cuando quiere permitir múltiples entidades, puede proporcionarlas como array:

$valid = new Zend_Validate_CreditCard(array(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
    Zend_Validate_CreditCard::VISA
));

Y como con todos los validadores, también puede pasar un array asociativo de opciones o una instancia de Zend_Config. En este caso debe proporcionar las entidades con la clave de array type como se simula aquí:

$valid = new Zend_Validate_CreditCard(array(
    'type' => array(Zend_Validate_CreditCard::AMERICAN_EXPRESS)
));

También puede establecer o añadir entidades después de la instanciación usando los métodos setType(), addType() y getType().

$valid = new Zend_Validate_CreditCard();
$valid->setType(array(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
    Zend_Validate_CreditCard::VISA
));

	Entidad predeterminada
	Cuando no se da ninguna entidad en la inicialización se usa ALL, que establece todas las entidades a la vez. En este caso el uso de addType() es inútil porque todas las entidades ya se han añadido.

Como se dijo antes, Zend_Validate_CreditCard solo validará el número de tarjeta de crédito. Afortunadamente, algunas entidades proporcionan APIs en línea que pueden validar un número de tarjeta de crédito usando algoritmos que no están disponibles al público. La mayoría de estos servicios son de pago. Por lo tanto, esta comprobación está desactivada por defecto.

Cuando tenga acceso a dicha API, puede usarla como un complemento para Zend_Validate_CreditCard y aumentar la seguridad de la validación.

Para hacerlo, simplemente necesita dar un callback que se llamará cuando la validación genérica haya pasado. Esto evita que se llame a la API para números no válidos, lo que aumenta el rendimiento de la aplicación.

setService() establece un nuevo servicio, y getService() devuelve el servicio establecido. Como opción de configuración, puede dar la clave de array 'service' en la inicialización. Para más detalles sobre las posibles opciones eche un vistazo a Callback.

// Your service class
class CcService
{
    public function checkOnline($cardnumber, $types)
    {
        // some online validation
    }
}

// The validation
$service = new CcService();
$valid   = new Zend_Validate_CreditCard(Zend_Validate_CreditCard::VISA);
$valid->setService(array($service, 'checkOnline'));

Como puede ver, el método callback se llamará con el número de tarjeta de crédito como primer parámetro, y los tipos aceptados como segundo parámetro.

Se admiten las siguientes opciones para Zend_Validate_Date:

La forma más fácil de validar una fecha es usando el formato de fecha predeterminado. Se usa cuando no se ha dado ninguna configuración regional ni ningún formato.

$validator = new Zend_Validate_Date();

$validator->isValid('2000-10-10');   // returns true
$validator->isValid('10.10.2000'); // returns false

El formato de fecha predeterminado para Zend_Validate_Date es 'yyyy-MM-dd'.

Zend_Validate_Date también valida fechas dadas en un formato localizado. Usando la opción locale puede definir la configuración regional que debe usar el formato de fecha para la validación.

$validator = new Zend_Validate_Date(array('locale' => 'de'));

$validator->isValid('10.Feb.2010'); // returns true
$validator->isValid('10.May.2010'); // returns false

La opción locale establece el formato de fecha predeterminado. En el ejemplo anterior este es 'dd.MM.yyyy', que se define como formato de fecha predeterminado para 'de'.

Zend_Validate_Date también admite formatos de fecha definidos por el usuario. Cuando quiera validar tal fecha puede usar la opción format.

$validator = new Zend_Validate_Date(array('format' => 'yyyy'));

$validator->isValid('2010'); // returns true
$validator->isValid('May');  // returns false

Por supuesto puede combinar format y locale. En este caso también puede usar nombres de mes o de día localizados.

$validator = new Zend_Validate_Date(array('format' => 'yyyy MMMM', 'locale' => 'de'));

$validator->isValid('2010 Dezember'); // returns true
$validator->isValid('2010 June');     // returns false

Se admiten las siguientes opciones para Zend_Validate_Db_NoRecordExists y Zend_Validate_Db_RecordExists:

Un ejemplo de uso básico de los validadores:

//Check that the email address exists in the database
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table' => 'users',
        'field' => 'emailaddress'
    )
);

if ($validator->isValid($emailaddress)) {
    // email address appears to be valid
} else {
    // email address is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Lo anterior probará que una dirección de correo electrónico determinada está en la tabla de la base de datos. Si no se encuentra ningún registro que contenga el valor de $emailaddress en la columna especificada, se muestra un mensaje de error.

//Check that the username is not present in the database
$validator = new Zend_Validate_Db_NoRecordExists(
    array(
        'table' => 'users',
        'field' => 'username'
    )
);
if ($validator->isValid($username)) {
    // username appears to be valid
} else {
    // username is invalid; print the reason
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

Lo anterior probará que un nombre de usuario determinado no está en la tabla de la base de datos. Si se encuentra un registro que contiene el valor de $username en la columna especificada, se muestra un mensaje de error.

Zend_Validate_Db_RecordExists y Zend_Validate_Db_NoRecordExists también proporcionan un medio para probar la base de datos, excluyendo una parte de la tabla, ya sea proporcionando una cláusula where como cadena, o un array con las claves "field" y "value".

Cuando se proporciona un array para la cláusula de exclusión, se usa el operador !=, de modo que puede comprobar el resto de una tabla en busca de un valor antes de modificar un registro (por ejemplo en un formulario de perfil de usuario)

//Check no other users have the username
$user_id   = $user->getId();
$validator = new Zend_Validate_Db_NoRecordExists(
    array(
        'table' => 'users',
        'field' => 'username',
        'exclude' => array(
            'field' => 'id',
            'value' => $user_id
        )
    )
);

if ($validator->isValid($username)) {
    // username appears to be valid
} else {
    // username is invalid; print the reason
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

El ejemplo anterior comprobará la tabla para asegurar que ningún registro salvo aquel donde id = $user_id contiene el valor $username.

También puede proporcionar una cadena para la cláusula de exclusión, de modo que pueda usar un operador distinto de !=. Esto puede ser útil para probar contra claves compuestas.

$email     = 'user@example.com';
$clause    = $db->quoteInto('email = ?', $email);
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'   => 'users',
        'field'   => 'username',
        'exclude' => $clause
    )
);

if ($validator->isValid($username)) {
    // username appears to be valid
} else {
    // username is invalid; print the reason
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

El ejemplo anterior comprobará la tabla 'users' para asegurar que solo un registro con tanto el nombre de usuario $username como el email $email es válido.

También puede especificar un adaptador. Esto le permitirá trabajar con aplicaciones que usan múltiples adaptadores de base de datos, o donde no ha establecido un adaptador predeterminado. Como en el siguiente ejemplo:

$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table' => 'users',
        'field' => 'id',
        'adapter' => $dbAdapter
    )
);

Puede especificar un esquema dentro de su base de datos para adaptadores como PostgreSQL y DB/2 simplemente proporcionando un array con las claves table y schema. Como en el siguiente ejemplo:

$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'  => 'users',
        'schema' => 'my',
        'field'  => 'id'
    )
);

No hay opciones adicionales para Zend_Validate_Digits:

Para validar si un valor determinado contiene solo dígitos y ningún otro carácter, simplemente llame al validador como se muestra en este ejemplo:

$validator = new Zend_Validate_Digits();

$validator->isValid("1234567890"); // returns true
$validator->isValid(1234);         // returns true
$validator->isValid('1a234');      // returns false

	Validar números
	Cuando quiera validar números o valores numéricos, tenga en cuenta que este validador solo valida dígitos. Esto significa que cualquier otro signo como un separador de miles o una coma no pasará este validador. En este caso debería usar Zend_Validate_Int o Zend_Validate_Float.

Un ejemplo básico de uso está a continuación:

$validator = new Zend_Validate_EmailAddress();
if ($validator->isValid($email)) {
    // email appears to be valid
} else {
    // email is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Esto cotejará la dirección de correo electrónico $email y, en caso de fallo, rellenará getMessages() con mensajes de error útiles.

Zend_Validate_EmailAddress admite varias opciones que se pueden establecer bien en la inicialización, dando un array con las opciones relacionadas, o posteriormente, usando setOptions(). Se admiten las siguientes opciones:

$validator = new Zend_Validate_EmailAddress();
$validator->setOptions(array('domain' => false));

Zend_Validate_EmailAddress cotejará cualquier dirección de correo electrónico válida según RFC2822. Por ejemplo, los correos válidos incluyen bob@domain.com, bob+jones@domain.us, "bob@jones"@domain.com y "bob jones"@domain.com.

Algunos formatos de correo electrónico obsoletos actualmente no se validarán (p. ej. retornos de carro o un carácter "\" en una dirección de correo electrónico).

Si necesita que Zend_Validate_EmailAddress compruebe solo la parte local de una dirección de correo electrónico, y quiere deshabilitar la validación del nombre de host, puede establecer la opción domain en FALSE. Esto obliga a Zend_Validate_EmailAddress a no validar la parte de nombre de host de la dirección de correo electrónico.

$validator = new Zend_Validate_EmailAddress();
$validator->setOptions(array('domain' => FALSE));

La parte de nombre de host de una dirección de correo electrónico se valida contra Zend_Validate_Hostname. Por defecto solo se aceptan nombres de host DNS de la forma domain.com, aunque si lo desea también puede aceptar direcciones IP y nombres de host locales.

Para hacer esto necesita instanciar Zend_Validate_EmailAddress pasando un parámetro para indicar el tipo de nombres de host que quiere aceptar. Hay más detalles incluidos en Zend_Validate_Hostname, aunque a continuación aparece un ejemplo de cómo aceptar nombres de host tanto DNS como locales:

$validator = new Zend_Validate_EmailAddress(
                    Zend_Validate_Hostname::ALLOW_DNS |
                    Zend_Validate_Hostname::ALLOW_LOCAL);
if ($validator->isValid($email)) {
    // email appears to be valid
} else {
    // email is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Solo porque una dirección de correo electrónico esté en el formato correcto, no significa necesariamente que esa dirección de correo realmente exista. Para ayudar a resolver este problema, puede usar la validación MX para comprobar si existe una entrada MX (correo) en el registro DNS para el nombre de host del correo. Esto le dice que el nombre de host acepta correo, pero no le dice que la dirección de correo electrónico exacta en sí sea válida.

La comprobación MX no está habilitada por defecto. Para habilitar la comprobación MX puede pasar un segundo parámetro al constructor de Zend_Validate_EmailAddress.

$validator = new Zend_Validate_EmailAddress(
    array(
        'allow' => Zend_Validate_Hostname::ALLOW_DNS,
        'mx'    => true
    )
);

	Comprobación MX en Windows
	Dentro de entornos Windows la comprobación MX solo está disponible cuando se usa PHP 5.3 o superior. Por debajo de PHP 5.3 la comprobación MX no se usará aunque esté activada dentro de las opciones.

Alternativamente puede pasar TRUE o FALSE a setValidateMx() para habilitar o deshabilitar la validación MX.

Al habilitar esta configuración se usarán funciones de red para comprobar la presencia de un registro MX en el nombre de host de la dirección de correo electrónico que desea validar. Tenga en cuenta que esto probablemente ralentizará su script.

A veces la validación de registros MX devuelve FALSE, incluso si se aceptan los correos. La razón detrás de este comportamiento es que los servidores pueden aceptar correos incluso si no proporcionan un registro MX. En este caso pueden proporcionar registros A, A6 o AAAA. Para permitir que Zend_Validate_EmailAddress también compruebe estos otros registros, necesita establecer la validación MX profunda. Esto se puede hacer en la inicialización estableciendo la opción deep o usando setOptions().

$validator = new Zend_Validate_EmailAddress(
    array(
        'allow' => Zend_Validate_Hostname::ALLOW_DNS,
        'mx'    => true,
        'deep'  => true
    )
);

	Advertencia de rendimiento
	Debe tener en cuenta que habilitar la comprobación MX ralentizará su script debido a las funciones de red usadas. Habilitar la comprobación profunda ralentizará su script aún más, ya que busca en el servidor dado 3 tipos adicionales.

	Direcciones IP no permitidas
	Debe tener en cuenta que la validación MX solo se acepta para servidores externos. Cuando la validación MX profunda está habilitada, las direcciones IP locales como 192.168.* o 169.254.* no se aceptan.

Zend_Validate_EmailAddress también cotejará caracteres internacionales que existen en algunos dominios. Esto se conoce como soporte de International Domain Name (IDN). Esto está habilitado por defecto, aunque puede deshabilitarlo cambiando la configuración a través del objeto interno Zend_Validate_Hostname que existe dentro de Zend_Validate_EmailAddress.

$validator->getHostnameValidator()->setValidateIdn(false);

Más información sobre el uso de setValidateIdn() aparece en la documentación de Zend_Validate_Hostname.

Tenga en cuenta que los IDN solo se validan si permite que se validen nombres de host DNS.

Por defecto, un nombre de host se comprobará contra una lista de TLD conocidos. Esto está habilitado por defecto, aunque puede deshabilitarlo cambiando la configuración a través del objeto interno Zend_Validate_Hostname que existe dentro de Zend_Validate_EmailAddress.

$validator->getHostnameValidator()->setValidateTld(false);

Más información sobre el uso de setValidateTld() aparece en la documentación de Zend_Validate_Hostname.

Tenga en cuenta que los TLD solo se validan si permite que se validen nombres de host DNS.

Zend_Validate_EmailAddress también hace uso de Zend_Validate_Hostname para comprobar la parte de nombre de host de una dirección de correo electrónico determinada. Al igual que con Zend Framework 1.10 puede simplemente establecer mensajes para Zend_Validate_Hostname desde dentro de Zend_Validate_EmailAddress.

$validator = new Zend_Validate_EmailAddress();
$validator->setMessages(
    array(
        Zend_Validate_Hostname::UNKNOWN_TLD => "I don't know the TLD you gave"
    )
);

Antes de Zend Framework 1.10 tenía que adjuntar los mensajes a su propio Zend_Validate_Hostname, y luego establecer este validador dentro de Zend_Validate_EmailAddress para obtener sus propios mensajes devueltos.

Se admiten las siguientes opciones para Zend_Validate_Float:

La forma más simple de validar un valor flotante es usando la configuración del sistema. Cuando no se usa ninguna opción, se usa la configuración regional del entorno para la validación:

$validator = new Zend_Validate_Float();

$validator->isValid(1234.5);   // returns true
$validator->isValid('10a01'); // returns false
$validator->isValid('1,234.5'); // returns true

En el ejemplo anterior esperábamos que nuestro entorno esté configurado con "en" como configuración regional.

A menudo es útil poder validar también valores localizados. Los valores flotantes a menudo se escriben de forma diferente en otros países. Por ejemplo usando inglés escribirá "1.5". En alemán puede escribir "1,5" y en otros idiomas puede usar agrupación.

Zend_Validate_Float es capaz de validar tales notaciones. Pero está limitado a la configuración regional que establezca. Vea el siguiente código:

$validator = new Zend_Validate_Float(array('locale' => 'de'));

$validator->isValid(1234.5); // returns true
$validator->isValid("1 234,5"); // returns false
$validator->isValid("1.234"); // returns true

Como puede ver, al usar una configuración regional, su entrada se valida de forma localizada. Al usar una notación diferente obtiene un FALSE cuando la configuración regional fuerza una notación diferente.

La configuración regional también se puede establecer posteriormente usando setLocale() y recuperar usando getLocale().

Se admiten las siguientes opciones para Zend_Validate_GreaterThan:

Para validar si un valor determinado es mayor que un límite definido simplemente use el siguiente ejemplo.

$valid  = new Zend_Validate_GreaterThan(array('min' => 10));
$value  = 11;
$return = $valid->isValid($value);
// returns true

El ejemplo anterior devuelve TRUE para todos los valores que son mayores que 10.

$valid  = new Zend_Validate_GreaterThan(array('min' => 10));
$value  = 10;
$return = $valid->isValid($value);
// returns false

El ejemplo anterior devuelve FALSE para todos los valores que son menores o iguales al valor límite mínimo.

No hay opciones adicionales para Zend_Validate_Hex:

Se admiten las siguientes opciones para Zend_Validate_Hostname:

Un ejemplo básico de uso está a continuación:

$validator = new Zend_Validate_Hostname();
if ($validator->isValid($hostname)) {
    // hostname appears to be valid
} else {
    // hostname is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Esto cotejará el nombre de host $hostname y, en caso de fallo, rellenará getMessages() con mensajes de error útiles.

Puede encontrar que también quiere cotejar direcciones IP, nombres de host locales, o una combinación de todos los tipos permitidos. Esto se puede hacer pasando un parámetro a Zend_Validate_Hostname cuando lo instancie. El parámetro debe ser un entero que determine qué tipos de nombres de host se permiten. Se le anima a usar las constantes de Zend_Validate_Hostname para hacer esto.

Las constantes de Zend_Validate_Hostname son: ALLOW_DNS para permitir solo nombres de host DNS, ALLOW_IP para permitir direcciones IP, ALLOW_LOCAL para permitir nombres de red locales, ALLOW_URI para permitir direcciones conformes a RFC3986, y ALLOW_ALL para permitir los cuatro tipos anteriores.

	Información adicional sobre ALLOW_URI
	ALLOW_URI permite comprobar nombres de host según RFC3986. Estos son nombres registrados que usan WINS, NetInfo y también nombres de host locales como los definidos en su archivo .hosts.

Para comprobar solo direcciones IP puede usar el siguiente ejemplo:

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_IP);
if ($validator->isValid($hostname)) {
    // hostname appears to be valid
} else {
    // hostname is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Además de usar ALLOW_ALL para aceptar todos los tipos de nombres de host comunes, puede combinar estos tipos para permitir combinaciones. Por ejemplo, para aceptar nombres de host DNS y locales, instancie su objeto Zend_Validate_Hostname así:

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS |
                                        Zend_Validate_Hostname::ALLOW_IP);

Algunos dominios de código de país de nivel superior (ccTLD), como 'de' (Alemania), admiten caracteres internacionales en nombres de dominio. Esto se conoce como International Domain Names (IDN). Estos dominios pueden ser cotejados por Zend_Validate_Hostname mediante caracteres extendidos que se usan en el proceso de validación.

	Dominios IDN
	Hasta ahora más de 50 ccTLD admiten dominios IDN.

Para cotejar un dominio IDN es tan simple como usar el validador Hostname estándar, ya que la comprobación IDN está habilitada por defecto. Si desea deshabilitar la validación IDN esto se puede hacer bien pasando un parámetro al constructor de Zend_Validate_Hostname o mediante el método setValidateIdn().

Puede deshabilitar la validación IDN pasando un segundo parámetro al constructor de Zend_Validate_Hostname de la siguiente manera.

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => false
        )
    );

Alternativamente puede pasar TRUE o FALSE a setValidateIdn() para habilitar o deshabilitar la validación IDN. Si está intentando cotejar un nombre de host IDN que actualmente no se admite, es probable que falle la validación si tiene algún carácter internacional. Cuando no existe un archivo de ccTLD en Zend/Validate/Hostname que especifique los caracteres adicionales, se realiza una validación de nombre de host normal.

	Validación IDN
	Tenga en cuenta que los IDN solo se validan si permite que se validen nombres de host DNS.

Por defecto, un nombre de host se comprobará contra una lista de TLD conocidos. Si esta funcionalidad no es necesaria, se puede deshabilitar de la misma manera que al deshabilitar el soporte IDN. Puede deshabilitar la validación TLD pasando un tercer parámetro al constructor de Zend_Validate_Hostname. En el siguiente ejemplo estamos admitiendo la validación IDN mediante el segundo parámetro.

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => true,
            'tld'   => false
        )
    );

Alternativamente puede pasar TRUE o FALSE a setValidateTld() para habilitar o deshabilitar la validación TLD.

	Validación TLD
	Tenga en cuenta que los TLD solo se validan si permite que se validen nombres de host DNS.

Se admiten las siguientes opciones para Zend_Validate_Iban:

Los números IBAN siempre están relacionados con un país. Esto significa que diferentes países usan diferentes formatos para sus números IBAN. Esta es la razón por la que los números IBAN siempre necesitan una configuración regional. Sabiendo esto ya sabemos cómo usar Zend_Validate_Iban.

76.2.16.2.1. Configuración regional de toda la aplicación

Podríamos usar la configuración regional de toda la aplicación. Esto significa que cuando no se da ninguna opción en la inicialización, Zend_Validate_Iban busca la configuración regional de toda la aplicación. Vea el siguiente fragmento de código:

// within bootstrap
Zend_Registry::set('Zend_Locale', new Zend_Locale('de_AT'));

// within the module
$validator = new Zend_Validate_Iban();

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}

	Configuración regional de toda la aplicación
	Por supuesto esto solo funciona cuando se estableció previamente una configuración regional de toda la aplicación en el registro. De lo contrario Zend_Locale intentará usar la configuración regional que envíe el cliente o, cuando no se envíe ninguna, usa la configuración regional del entorno. Tenga en cuenta que esto puede llevar a un comportamiento no deseado dentro de la validación.

$validator = new Zend_Validate_Iban(array('locale' => false));
// Note: you can also set a FALSE as single parameter

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}

76.2.16.2.3. Validación IBAN sensible a la región

Para validar contra un país definido, solo necesita dar la configuración regional deseada. Puede hacer esto mediante la opción locale y también posteriormente usando setLocale().

$validator = new Zend_Validate_Iban(array('locale' => 'de_AT'));

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}

	Use configuraciones regionales completamente calificadas
	Debe dar una configuración regional completamente calificada, de lo contrario el país no se podría detectar correctamente porque los idiomas se hablan en múltiples países.

Se admiten las siguientes opciones para Zend_Validate_Identical:

Para validar si dos valores son idénticos necesita establecer el valor de origen como haystack. Vea el siguiente ejemplo que valida dos cadenas.

$valid = new Zend_Validate_Identical('origin');
if ($valid->isValid($value) {
    return true;
}

La validación solo devolverá TRUE cuando ambos valores sean 100% idénticos. En nuestro ejemplo, cuando $value es 'origin'.

También puede establecer el token deseado posteriormente usando el método setToken() y getToken() para obtener el token establecido actualmente.

Por supuesto Zend_Validate_Identical puede validar no solo cadenas, sino también cualquier otro tipo de variable como Booleano, Entero, Flotante, Array o incluso Objetos. Como ya se ha señalado, Haystack y Value deben ser idénticos.

$valid = new Zend_Validate_Identical(123);
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

	Comparación de tipos
	Debe tener en cuenta que también se usa el tipo de una variable para la validación. Esto significa que la cadena '3' no es idéntica al entero 3. Cuando quiera una validación no estricta debe establecer la opción strict.

Zend_Validate_Identical también admite la comparación de elementos de formulario. Esto se puede hacer usando el nombre del elemento como token. Vea el siguiente ejemplo:

$form->addElement('password', 'elementOne');
$form->addElement('password', 'elementTwo', array(
    'validators' => array(
        array('identical', false, array('token' => 'elementOne'))
    )
));

Usando el nombre del primer elemento como token para el segundo elemento, el validador valida si el segundo elemento es igual al primer elemento. En caso de que su usuario no introduzca dos valores idénticos, obtendrá un error de validación.

Como se mencionó antes, Zend_Validate_Identical valida los tokens de forma estricta. Puede cambiar este comportamiento usando la opción strict. El valor predeterminado para esta propiedad es TRUE.

$valid = new Zend_Validate_Identical(array('token' => 123, 'strict' => FALSE));
$input = '123';
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

La diferencia con el ejemplo anterior es que la validación devuelve en este caso TRUE, incluso si compara un valor entero con uno de cadena siempre que el contenido sea idéntico pero no el tipo.

Por conveniencia también puede usar setStrict() y getStrict().

Como todos los demás validadores, Zend_Validate_Identical también admite el uso de configuraciones como parámetro de entrada. Esto significa que puede configurar este validador con un objeto Zend_Config.

Pero esto añade un caso del que debe ser consciente. Cuando use un array como haystack, debería envolverlo dentro de una clave 'token' cuando pudiera contener un solo elemento.

$valid = new Zend_Validate_Identical(array('token' => 123));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

El ejemplo anterior valida el entero 123. La razón de este caso especial es que puede configurar el token que se debe usar dando la clave 'token'.

Así que, cuando su haystack contiene un elemento y este elemento se llama 'token', entonces debe envolverlo como se muestra en el ejemplo de abajo.

$valid = new Zend_Validate_Identical(array('token' => array('token' => 123)));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Se admiten las siguientes opciones para Zend_Validate_InArray:

La forma más simple es simplemente dar el array contra el que se debe buscar en la inicialización:

$validator = new Zend_Validate_InArray(array('key' => 'value',
                                             'otherkey' => 'othervalue'));
if ($validator->isValid('value')) {
    // value found
} else {
    // no value found
}

Esto se comportará exactamente como el método in_array() de PHP.

	Nota
	Por defecto esta validación no es estricta ni puede validar arrays multidimensionales.

Por supuesto también puede dar el array contra el que validar posteriormente usando el método setHaystack(). getHaystack() devuelve el array haystack establecido actualmente.

$validator = new Zend_Validate_InArray();
$validator->setHaystack(array('key' => 'value', 'otherkey' => 'othervalue'));

if ($validator->isValid('value')) {
    // value found
} else {
    // no value found
}

Como se mencionó antes, también puede hacer una validación estricta dentro del array. Por defecto no habría diferencia entre el valor entero 0 y la cadena "0". Al hacer una validación estricta esta diferencia también se validará y solo se aceptan los mismos tipos.

Una validación estricta también se puede hacer usando dos formas diferentes. En la inicialización y mediante un método. En la inicialización debe dar un array con la siguiente estructura:

$validator = new Zend_Validate_InArray(
    array(
        'haystack' => array('key' => 'value', 'otherkey' => 'othervalue'),
        'strict'   => true
    )
);

if ($validator->isValid('value')) {
    // value found
} else {
    // no value found
}

La clave haystack contiene su array contra el que validar. Y al establecer la clave strict en TRUE, la validación se hace usando una comprobación estricta de tipos.

Por supuesto también puede usar el método setStrict() para cambiar esta configuración posteriormente y getStrict() para obtener el estado establecido actualmente.

	Nota
	Tenga en cuenta que la configuración strict es por defecto FALSE.

Además del método in_array() de PHP, este validador también se puede usar para validar arrays multidimensionales.

Para validar arrays multidimensionales debe establecer la opción recursive.

$validator = new Zend_Validate_InArray(
    array(
        'haystack' => array(
            'firstDimension' => array('key' => 'value',
                                      'otherkey' => 'othervalue'),
            'secondDimension' => array('some' => 'real',
                                       'different' => 'key')),
        'recursive' => true
    )
);

if ($validator->isValid('value')) {
    // value found
} else {
    // no value found
}

Su array se validará entonces de forma recursiva para ver si el valor dado está contenido. Además podría usar setRecursive() para establecer esta opción posteriormente y getRecursive() para recuperarla.

$validator = new Zend_Validate_InArray(
    array(
        'firstDimension' => array('key' => 'value',
                                  'otherkey' => 'othervalue'),
        'secondDimension' => array('some' => 'real',
                                   'different' => 'key')
    )
);
$validator->setRecursive(true);

if ($validator->isValid('value')) {
    // value found
} else {
    // no value found
}

	Configuración predeterminada para la recursión
	Por defecto la validación recursiva está desactivada.

	Claves de opción dentro del haystack
	Cuando use las claves 'haystack', 'strict' o 'recursive' dentro de su haystack, debe envolver la clave haystack.

Se admiten las siguientes opciones para Zend_Validate_Int:

La forma más simple de validar un entero es usando la configuración del sistema. Cuando no se usa ninguna opción, se usa la configuración regional del entorno para la validación:

$validator = new Zend_Validate_Int();

$validator->isValid(1234);   // returns true
$validator->isValid(1234.5); // returns false
$validator->isValid('1,234'); // returns true

En el ejemplo anterior esperábamos que nuestro entorno esté configurado con "en" como configuración regional. Como puede ver en el tercer ejemplo, también se reconoce la agrupación.

A menudo es útil poder validar también valores localizados. Los valores enteros a menudo se escriben de forma diferente en otros países. Por ejemplo usando inglés puede escribir "1234" o "1,234". Ambos son valores enteros pero la agrupación es opcional. En alemán, por ejemplo, puede escribir "1.234" y en francés "1 234".

Zend_Validate_Int es capaz de validar tales notaciones. Pero está limitado a la configuración regional que establezca. Esto significa que no simplemente elimina el separador, valida si se usa el separador correcto. Vea el siguiente código:

$validator = new Zend_Validate_Int(array('locale' => 'de'));

$validator->isValid(1234); // returns true
$validator->isValid("1,234"); // returns false
$validator->isValid("1.234"); // returns true

Como puede ver, al usar una configuración regional, su entrada se valida de forma localizada. Usando la notación inglesa obtiene un FALSE cuando la configuración regional fuerza una notación diferente.

La configuración regional también se puede establecer posteriormente usando setLocale() y recuperar usando getLocale().

Se admiten las siguientes opciones para Zend_Validate_Ip:

Un ejemplo básico de uso está a continuación:

$validator = new Zend_Validate_Ip();
if ($validator->isValid($ip)) {
    // ip appears to be valid
} else {
    // ip is invalid; print the reasons
}

	Direcciones IP no válidas
	Tenga en cuenta que Zend_Validate_Ip solo valida direcciones IP. Direcciones como 'mydomain.com' o '192.168.50.1/index.html' no son direcciones IP válidas. Son o bien nombres de host o URLs válidas pero no direcciones IP.

	Validación IPv6
	Zend_Validate_Ip valida direcciones IPv6 con expresiones regulares. La razón es que los filtros y métodos del propio PHP no siguen la RFC. Muchas otras clases disponibles tampoco la siguen.

A veces es útil validar solo uno de los formatos admitidos. Por ejemplo cuando su red solo admite IPv4. En este caso sería inútil permitir IPv6 dentro de este validador.

Para limitar Zend_Validate_Ip a un protocolo puede establecer las opciones allowipv4 o allowipv6 en FALSE. Puede hacer esto bien dando la opción al constructor o usando setOptions() posteriormente.

$validator = new Zend_Validate_Ip(array('allowipv6' => false);
if ($validator->isValid($ip)) {
    // ip appears to be valid ipv4 address
} else {
    // ip is no ipv4 address
}

	Comportamiento predeterminado
	El comportamiento predeterminado que sigue Zend_Validate_Ip es permitir ambos estándares.

Se admiten las siguientes opciones para Zend_Validate_Isbn:

Un ejemplo básico de uso está a continuación:

$validator = new Zend_Validate_Isbn();
if ($validator->isValid($isbn)) {
    // isbn is valid
} else {
    // isbn is not valid
}

Esto validará cualquier ISBN-10 e ISBN-13 sin separador.

Un ejemplo de restricción de tipo ISBN está a continuación:

$validator = new Zend_Validate_Isbn();
$validator->setType(Zend_Validate_Isbn::ISBN13);
// OR
$validator = new Zend_Validate_Isbn(array(
    'type' => Zend_Validate_Isbn::ISBN13,
));

if ($validator->isValid($isbn)) {
    // this is a valid ISBN-13 value
} else {
    // this is an invalid ISBN-13 value
}

Lo anterior validará solo valores ISBN-13.

Los tipos válidos incluyen:

Un ejemplo de restricción de separador está a continuación:

$validator = new Zend_Validate_Isbn();
$validator->setSeparator('-');
// OR
$validator = new Zend_Validate_Isbn(array(
    'separator' => '-',
));

if ($validator->isValid($isbn)) {
    // this is a valid ISBN with separator
} else {
    // this is an invalid ISBN with separator
}

	Valores sin separador
	Esto devolverá FALSE si $isbn no contiene un separador o si es un valor ISBN no válido.

Los separadores válidos incluyen:

Se admiten las siguientes opciones para Zend_Validate_LessThan:

Para validar si un valor determinado es menor que un límite definido simplemente use el siguiente ejemplo.

$valid  = new Zend_Validate_LessThan(array('max' => 10));
$value  = 10;
$return = $valid->isValid($value);
// returns true

El ejemplo anterior devuelve TRUE para todos los valores que sean iguales a 10 o menores que 10.

Se admiten las siguientes opciones para Zend_Validate_NotEmpty:

Por defecto, este validador funciona de forma diferente a como esperaría cuando ha trabajado con la función empty() de PHP. En particular, este validador evaluará tanto el entero 0 como la cadena '0' como vacíos.

$valid = new Zend_Validate_NotEmpty();
$value  = '';
$result = $valid->isValid($value);
// returns false

	El comportamiento predeterminado difiere de PHP
	Sin proporcionar configuración, el comportamiento de Zend_Validate_NotEmpty difiere del de PHP.

Algunos proyectos tienen opiniones diferentes sobre lo que se considera un valor "vacío": una cadena con solo espacios en blanco podría considerarse vacía, o 0 puede considerarse no vacío (particularmente para secuencias booleanas). Para adaptarse a necesidades diferentes, Zend_Validate_NotEmpty le permite configurar qué tipos deben validarse como vacíos y cuáles no.

Se pueden manejar los siguientes tipos:

Todos los demás valores dados devolverán TRUE por defecto.

Hay varias formas de seleccionar cuáles de los tipos anteriores se validan. Puede dar uno o varios tipos y sumarlos, puede dar un array, puede usar constantes, o puede dar una cadena de texto. Vea los siguientes ejemplos:

// Returns false on 0
$validator = new Zend_Validate_NotEmpty(Zend_Validate_NotEmpty::INTEGER);

// Returns false on 0 or '0'
$validator = new Zend_Validate_NotEmpty(
    Zend_Validate_NotEmpty::INTEGER + Zend_NotEmpty::ZERO
);

// Returns false on 0 or '0'
$validator = new Zend_Validate_NotEmpty(array(
    Zend_Validate_NotEmpty::INTEGER,
    Zend_Validate_NotEmpty::ZERO
));

// Returns false on 0 or '0'
$validator = new Zend_Validate_NotEmpty(array(
    'integer',
    'zero',
));

También puede proporcionar una instancia de Zend_Config para establecer los tipos deseados. Para establecer tipos después de la instanciación, use el método setType().

En su forma más básica, puede pasar bien un objeto Zend_Locale o una cadena que represente una configuración regional completamente calificada al constructor de Zend_Validate_PostCode.

$validator = new Zend_Validate_PostCode('de_AT');
$validator = new Zend_Validate_PostCode($locale);

Además, puede pasar bien un array o un objeto Zend_Config al constructor. Cuando lo haga, debe incluir bien la clave "locale" o "format"; estas se usarán para establecer los valores apropiados en el objeto validador.

$validator = new Zend_Validate_PostCode(array(
    'locale' => 'de_AT',
    'format' => 'AT_\d+'
));

Se admiten las siguientes opciones para Zend_Validate_PostCode:

Se admiten las siguientes opciones para Zend_Validate_Regex:

La validación con expresiones regulares permite tener validaciones complicadas hechas sin escribir un validador propio. El uso de expresiones regulares es bastante común y simple. Veamos algunos ejemplos:

$validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');

$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns true
$validator->isValid("Pest"); // returns false

Como puede ver, el patrón debe darse usando la misma sintaxis que preg_match(). Para más detalles sobre expresiones regulares eche un vistazo al manual de PHP sobre la sintaxis de patrones PCRE.

También es posible establecer un patrón diferente posteriormente usando setPattern() y obtener el patrón establecido actualmente con getPattern().

$validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');
$validator->setPattern('ing$/');

$validator->isValid("Test"); // returns false
$validator->isValid("Testing"); // returns true
$validator->isValid("Pest"); // returns false

Valida si una cadena es válida para usarse como elemento 'changefreq' en un documento Sitemap XML. Los valores válidos son: 'always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', o 'never'.

Devuelve TRUE si y solo si el valor es una cadena y es igual a una de las frecuencias especificadas anteriormente.

Valida si una cadena es válida para usarse como elemento 'lastmod' en un documento Sitemap XML. El elemento lastmod debe contener una cadena de fecha W3C, descartando opcionalmente información sobre la hora.

Devuelve TRUE si y solo si el valor dado es una cadena y es válido según el protocolo.

$validator = new Zend_Validate_Sitemap_Lastmod();

$validator->isValid('1999-11-11T22:23:52-02:00'); // true
$validator->isValid('2008-05-12T00:42:52+02:00'); // true
$validator->isValid('1999-11-11'); // true
$validator->isValid('2008-05-12'); // true

$validator->isValid('1999-11-11t22:23:52-02:00'); // false
$validator->isValid('2008-05-12T00:42:60+02:00'); // false
$validator->isValid('1999-13-11'); // false
$validator->isValid('2008-05-32'); // false
$validator->isValid('yesterday'); // false

Valida si una cadena es válida para usarse como elemento 'loc' en un documento Sitemap XML. Esto usa Zend_Form::check() internamente. Lea más en Validación de URI.

Valida si un valor es válido para usarse como elemento 'priority' en un documento Sitemap XML. El valor debe ser un decimal entre 0.0 y 1.0. Este validador acepta tanto valores numéricos como valores de cadena.

$validator = new Zend_Validate_Sitemap_Priority();

$validator->isValid('0.1'); // true
$validator->isValid('0.789'); // true
$validator->isValid(0.8); // true
$validator->isValid(1.0); // true

$validator->isValid('1.1'); // false
$validator->isValid('-0.4'); // false
$validator->isValid(1.00001); // false
$validator->isValid(0xFF); // false
$validator->isValid('foo'); // false

No hay opciones admitidas para ninguno de los validadores Sitemap.

Se admiten las siguientes opciones para Zend_Validate_StringLength:

Por defecto este validador comprueba si un valor está entre min y max. Pero para min el valor predeterminado es 0 y para max es NULL, lo que significa ilimitado.

Así que por defecto, sin dar ninguna opción, este validador solo comprueba si la entrada es una cadena.

Para limitar la longitud máxima permitida de una cadena necesita establecer la propiedad max. Acepta un valor entero como entrada.

$validator = new Zend_Validate_StringLength(array('max' => 6));

$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns false

También puede establecer la longitud máxima permitida posteriormente usando el método setMax(). Y getMax() para recuperar el límite máximo actual.

$validator = new Zend_Validate_StringLength();
$validator->setMax(6);

$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns false

Para limitar la longitud mínima requerida de una cadena necesita establecer la propiedad min. También acepta un valor entero como entrada.

$validator = new Zend_Validate_StringLength(array('min' => 5));

$validator->isValid("Test"); // returns false
$validator->isValid("Testing"); // returns true

También puede establecer la longitud mínima solicitada posteriormente usando el método setMin(). Y getMin() para recuperar el límite mínimo actual.

$validator = new Zend_Validate_StringLength();
$validator->setMin(5);

$validator->isValid("Test"); // returns false
$validator->isValid("Testing"); // returns true

A veces se requiere obtener una cadena que tenga una longitud máxima definida pero que también tenga una longitud mínima. Por ejemplo cuando tiene un cuadro de texto donde un usuario puede introducir su nombre, entonces puede querer limitar el nombre a un máximo de 30 caracteres pero quiere asegurarse de que introdujo su nombre. Así que limita la longitud mínima requerida a 3 caracteres. Vea el siguiente ejemplo:

$validator = new Zend_Validate_StringLength(array('min' => 3, 'max' => 30));

$validator->isValid("."); // returns false
$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns true

	Establecer un límite máximo menor que el límite mínimo
	Cuando intenta establecer un valor máximo menor que el valor mínimo actual, o un valor mínimo mayor que el valor máximo actual, se lanzará una excepción.

Las cadenas siempre usan una codificación. Incluso cuando no establece la codificación explícitamente, PHP usa una. Cuando su aplicación usa una codificación diferente a la del propio PHP, entonces debería establecer una codificación usted mismo.

Puede establecer su propia codificación en la inicialización con la opción encoding, o usando el método setEncoding(). Supongamos que su instalación usa ISO y su aplicación está configurada en ISO. En este caso verá el siguiente comportamiento.

$validator = new Zend_Validate_StringLength(
    array('min' => 6)
);
$validator->isValid("Ärger"); // returns false

$validator->setEncoding("UTF-8");
$validator->isValid("Ärger"); // returns true

$validator2 = new Zend_Validate_StringLength(
    array('min' => 6, 'encoding' => 'UTF-8')
);
$validator2->isValid("Ärger"); // returns true

Así que cuando su instalación y su aplicación usan codificaciones diferentes, siempre debería establecer una codificación usted mismo.