Las siguientes opciones son soportadas para Zend_Filter_Alnum:

Vea el siguiente ejemplo del comportamiento por defecto de este filtro.

$filter = new Zend_Filter_Alnum();
$return = $filter->filter('This is (my) content: 123');
// returns 'Thisismycontent123'

El ejemplo anterior devuelve 'Thisismycontent123'. Como puede ver, todos los espacios en blanco y también los paréntesis son filtrados.

	Nota
	Zend_Filter_Alnum funciona en casi todos los idiomas. Pero en realidad hay tres excepciones: chino, japonés y coreano. Dentro de estos idiomas se usa el alfabeto inglés en lugar de los caracteres de estos idiomas. El idioma en sí se detecta usando Zend_Locale.

Zend_Filter_Alnum también puede permitir espacios en blanco. Esto puede ser útil cuando desea eliminar caracteres especiales de un texto. Vea el siguiente ejemplo:

$filter = new Zend_Filter_Alnum(array('allowwhitespace' => true));
$return = $filter->filter('This is (my) content: 123');
// returns 'This is my content 123'

El ejemplo anterior devuelve 'This is my content 123'. Como puede ver, solo se filtran los paréntesis, mientras que los espacios en blanco no se ven afectados.

Para cambiar allowWhiteSpace posteriormente puede usar setAllowWhiteSpace() y getAllowWhiteSpace().

Las siguientes opciones son soportadas para Zend_Filter_Alpha:

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_Alpha();

print $filter->filter('This is (my) content: 123');

El ejemplo anterior devuelve 'Thisismycontent'. Observe que los caracteres de espacio en blanco y los paréntesis se eliminan.

	Nota
	Zend_Filter_Alpha funciona en la mayoría de los idiomas; sin embargo, hay tres excepciones: chino, japonés y coreano. Con estos idiomas se usa el alfabeto inglés. El idioma se detecta mediante el uso de Zend_Locale.

Zend_Filter_Alpha también puede permitir caracteres de espacio en blanco. Esto puede ser útil cuando desea eliminar caracteres especiales de una cadena. Vea el siguiente ejemplo:

$filter = new Zend_Filter_Alpha(array('allowwhitespace' => true));

print $filter->filter('This is (my) content: 123');

El ejemplo anterior devuelve 'This is my content '. Observe que los paréntesis, los dos puntos y los números han sido eliminados, mientras que los caracteres de espacio en blanco permanecen.

Para cambiar allowWhiteSpace después de la instanciación puede usarse el método setAllowWhiteSpace().

Para consultar el valor actual de allowWhiteSpace puede usarse el método getAllowWhiteSpace().

No hay opciones adicionales para Zend_Filter_BaseName.

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_BaseName();

print $filter->filter('/vol/tmp/filename');

Esto devolverá 'filename'.

$filter = new Zend_Filter_BaseName();

print $filter->filter('/vol/tmp/filename.txt');

Esto devolverá 'filename.txt'.

Las siguientes opciones son soportadas para Zend_Filter_Boolean:

Por defecto, este filtro funciona convirtiendo la entrada a un valor BOOLEAN; en otras palabras, opera de forma similar a llamar a (boolean) $value.

$filter = new Zend_Filter_Boolean();
$value  = '';
$result = $filter->filter($value);
// returns false

Esto significa que, sin proporcionar ninguna configuración, Zend_Filter_Boolean acepta todos los tipos de entrada y devuelve un BOOLEAN tal como se obtendría al convertir el tipo a BOOLEAN.

A veces la conversión con (boolean) no será suficiente. Zend_Filter_Boolean le permite configurar tipos específicos a convertir, así como cuáles omitir.

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 filtran. Puede indicar uno o varios tipos y sumarlos, puede dar un array, puede usar constantes, o puede dar una cadena de texto. Vea los siguientes ejemplos:

// converts 0 to false
$filter = new Zend_Filter_Boolean(Zend_Filter_Boolean::INTEGER);

// converts 0 and '0' to false
$filter = new Zend_Filter_Boolean(
    Zend_Filter_Boolean::INTEGER + Zend_Filter_Boolean::ZERO
);

// converts 0 and '0' to false
$filter = new Zend_Filter_Boolean(array(
    'type' => array(
        Zend_Filter_Boolean::INTEGER,
        Zend_Filter_Boolean::ZERO,
    ),
));

// converts 0 and '0' to false
$filter = new Zend_Filter_Boolean(array(
    'type' => array(
        'integer',
        'zero',
    ),
));

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

Como se mencionó anteriormente, Zend_Filter_Boolean también puede reconocer las cadenas localizadas "yes" y "no". Esto significa que puede preguntarle a su cliente en un formulario "sí" o "no" en su idioma nativo y Zend_Filter_Boolean convertirá la respuesta al valor booleano apropiado.

Para establecer el idioma deseado, puede usar la opción locale, o el método setLocale().

$filter = new Zend_Filter_Boolean(array(
    'type'   => Zend_Filter_Boolean::ALL,
    'locale' => 'de',
));

// returns false
echo $filter->filter('nein');

$filter->setLocale('en');

// returns true
$filter->filter('yes');

A veces es necesario reconocer solo TRUE o FALSE y devolver todos los demás valores sin cambios. Zend_Filter_Boolean le permite hacer esto estableciendo la opción casting en FALSE.

En este caso Zend_Filter_Boolean funcionará como se describe en la siguiente tabla, que muestra qué valores devuelven TRUE o FALSE. Todos los demás valores dados se devuelven sin cambios cuando casting está establecido en FALSE

El siguiente ejemplo muestra el comportamiento al cambiar la opción casting:

$filter = new Zend_Filter_Boolean(array(
    'type'    => Zend_Filter_Boolean::ALL,
    'casting' => false,
));

// returns false
echo $filter->filter(0);

// returns true
echo $filter->filter(1);

// returns the value
echo $filter->filter(2);

Las siguientes opciones son soportadas para Zend_Filter_Callback:

El uso de este filtro es bastante simple. Supongamos que queremos crear un filtro que invierta una cadena.

$filter = new Zend_Filter_Callback('strrev');

print $filter->filter('Hello!');
// returns "!olleH"

Como puede ver, es realmente simple usar un callback para definir un filtro propio. También es posible usar un método definido dentro de una clase, dando un array como callback.

// Our classdefinition
class MyClass
{
    public function Reverse($param);
}

// The filter definition
$filter = new Zend_Filter_Callback(array('MyClass', 'Reverse'));
print $filter->filter('Hello!');

Para obtener el callback establecido actualmente use getCallback(), y para establecer otro callback use setCallback().

	Posibles excepciones
	Debe tener en cuenta que definir un método de callback que no se pueda invocar generará una excepción.

También es posible definir parámetros por defecto, que se pasan al método invocado como array cuando se ejecuta el filtro. Este array se concatenará con el valor que se va a filtrar.

$filter = new Zend_Filter_Callback(
    array(
        'callback' => 'MyMethod',
        'options'  => array('key' => 'param1', 'key2' => 'param2')
    )
);
$filter->filter(array('value' => 'Hello'));

Cuando llamara manualmente a la definición del método anterior, se vería así:

$value = MyMethod('Hello', 'param1', 'param2');

Las siguientes opciones son soportadas para Zend_Filter_Compress y Zend_Filter_Decompress:

Los siguientes formatos de compresión son soportados mediante su propio adaptador:

Cada formato de compresión tiene diferentes capacidades, como se describe a continuación. Todos los filtros de compresión pueden usarse de formas aproximadamente iguales, y difieren principalmente en las opciones disponibles y el tipo de compresión que ofrecen (tanto algorítmicamente como en términos de cadena frente a archivo frente a directorio)

Para crear un filtro de compresión necesita seleccionar el formato de compresión que quiere usar. La siguiente descripción toma el adaptador Bz2. Los detalles de todos los demás adaptadores se describen después de esta sección.

Los dos filtros son básicamente idénticos, ya que utilizan los mismos backends. Zend_Filter_Compress debe usarse cuando desee comprimir elementos, y Zend_Filter_Decompress debe usarse cuando desee descomprimirlos.

Por ejemplo, si queremos comprimir una cadena, tenemos que inicializar Zend_Filter_Compress e indicar el adaptador deseado.

$filter = new Zend_Filter_Compress('Bz2');

Para usar un adaptador diferente, simplemente lo especifica en el constructor.

También puede proporcionar un array de opciones o un objeto Zend_Config. Si lo hace, proporcione como mínimo la clave "adapter", y luego la clave "options" o "adapterOptions" (que debe ser un array de opciones para dar al adaptador en la instanciación).

$filter = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'blocksize' => 8,
    ),
));

	Adaptador de compresión por defecto
	Cuando no se proporciona ningún adaptador de compresión, se usará el adaptador Gz.

El uso es casi el mismo si queremos descomprimir una cadena. Simplemente debemos usar el filtro de descompresión en este caso.

$filter = new Zend_Filter_Decompress('Bz2');

Para obtener la cadena comprimida, tenemos que dar la cadena original. El valor filtrado es la versión comprimida de la cadena original.

$filter     = new Zend_Filter_Compress('Bz2');
$compressed = $filter->filter('Uncompressed string');
// Returns the compressed string

La descompresión funciona de la misma manera.

$filter     = new Zend_Filter_Decompress('Bz2');
$compressed = $filter->filter('Compressed string');
// Returns the uncompressed string

	Nota sobre la compresión de cadenas
	No todos los adaptadores soportan la compresión de cadenas. Formatos de compresión como Rar solo pueden manejar archivos y directorios. Para más detalles, consulte la sección del adaptador que desee usar.

Crear un archivo comprimido funciona casi igual que comprimir una cadena. Sin embargo, en este caso necesitamos un parámetro adicional que contenga el nombre del archivo que queremos crear.

$filter     = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'archive' => 'filename.bz2',
    ),
));
$compressed = $filter->filter('Uncompressed string');
// Returns true on success and creates the archive file

En el ejemplo anterior la cadena sin comprimir se comprime, y luego se escribe en el archivo comprimido indicado.

	Los archivos comprimidos existentes serán sobrescritos
	El contenido de cualquier archivo existente será sobrescrito cuando el nombre de archivo del archivo comprimido indicado ya exista.

Cuando desee comprimir un archivo, debe dar el nombre del archivo con su ruta.

$filter     = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'archive' => 'filename.bz2'
    ),
));
$compressed = $filter->filter('C:\temp\compressme.txt');
// Returns true on success and creates the archive file

También puede especificar un directorio en lugar de un nombre de archivo. En este caso todo el directorio con todos sus archivos y subdirectorios será comprimido en el archivo comprimido.

$filter     = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'archive' => 'filename.bz2'
    ),
));
$compressed = $filter->filter('C:\temp\somedir');
// Returns true on success and creates the archive file

	No comprima directorios grandes o base
	Nunca debe comprimir directorios grandes o base, como una partición completa. Comprimir una partición completa es una tarea que consume mucho tiempo y que puede llevar a problemas masivos en su servidor cuando no hay suficiente espacio o su script tarda demasiado tiempo.

Descomprimir un archivo comprimido funciona casi igual que comprimirlo. Debe especificar el parámetro archive, o dar el nombre de archivo del archivo comprimido cuando descomprima el archivo.

$filter     = new Zend_Filter_Decompress('Bz2');
$compressed = $filter->filter('filename.bz2');
// Returns true on success and decompresses the archive file

Algunos adaptadores soportan descomprimir el archivo en otro subdirectorio. En este caso puede establecer el parámetro target.

$filter     = new Zend_Filter_Decompress(array(
    'adapter' => 'Zip',
    'options' => array(
        'target' => 'C:\temp',
    )
));
$compressed = $filter->filter('filename.zip');
// Returns true on success and decompresses the archive file
// into the given target directory

	Los directorios de extracción deben existir
	Cuando desee descomprimir un archivo comprimido en un directorio, ese directorio debe existir.

El adaptador Bz2 puede comprimir y descomprimir:

Este adaptador hace uso de la extensión Bz2 de PHP.

Para personalizar la compresión, este adaptador soporta las siguientes opciones:

Todas las opciones se pueden establecer en la instanciación o usando un método relacionado. Por ejemplo, los métodos relacionados para 'Blocksize' son getBlocksize() y setBlocksize(). También puede usar el método setOptions(), que acepta todas las opciones como array.

El adaptador Gz puede comprimir y descomprimir:

Este adaptador hace uso de la extensión Zlib de PHP.

Para personalizar la compresión, este adaptador soporta las siguientes opciones:

Todas las opciones se pueden establecer en la inicialización o usando un método relacionado. Por ejemplo, los métodos relacionados para 'Level' son getLevel() y setLevel(). También puede usar el método setOptions(), que acepta todas las opciones como array.

El adaptador Lzf puede comprimir y descomprimir:

	Lzf solo soporta cadenas
	El adaptador Lzf no puede manejar archivos ni directorios.

Este adaptador hace uso de la extensión Lzf de PHP.

No hay opciones disponibles para personalizar este adaptador.

El adaptador Rar puede comprimir y descomprimir:

	Rar no soporta cadenas
	El adaptador Rar no puede manejar cadenas.

Este adaptador hace uso de la extensión Rar de PHP.

	La compresión Rar no está soportada
	Debido a restricciones con el formato de compresión Rar, no hay compresión disponible de forma gratuita. Cuando desee comprimir archivos en un nuevo archivo Rar, debe proporcionar un callback al adaptador que pueda invocar un programa de compresión Rar.

Para personalizar la compresión, este adaptador soporta las siguientes opciones:

Todas las opciones se pueden establecer en la instanciación o usando un método relacionado. Por ejemplo, los métodos relacionados para 'Target' son getTarget() y setTarget(). También puede usar el método setOptions(), que acepta todas las opciones como array.

El adaptador Tar puede comprimir y descomprimir:

	Tar no soporta cadenas
	El adaptador Tar no puede manejar cadenas.

Este adaptador hace uso del componente Archive_Tar de PEAR.

Para personalizar la compresión, este adaptador soporta las siguientes opciones:

Todas las opciones se pueden establecer en la instanciación o usando un método relacionado. Por ejemplo, los métodos relacionados para 'Target' son getTarget() y setTarget(). También puede usar el método setOptions(), que acepta todas las opciones como array.

	Uso de directorios
	Al comprimir directorios con Tar se usa la ruta completa del archivo. Esto significa que los archivos Tar creados no solo tendrán el subdirectorio, sino la ruta completa del archivo comprimido.

El adaptador Zip puede comprimir y descomprimir:

	Zip no soporta descompresión a cadena
	El adaptador Zip no puede manejar la descompresión a una cadena; la descompresión siempre se escribirá en un archivo.

Este adaptador hace uso de la extensión Zip de PHP.

Para personalizar la compresión, este adaptador soporta las siguientes opciones:

Todas las opciones se pueden establecer en la instanciación o usando un método relacionado. Por ejemplo, los métodos relacionados para 'Target' son getTarget() y setTarget(). También puede usar el método setOptions(), que acepta todas las opciones como array.

No hay opciones adicionales para Zend_Filter_Digits.

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_Digits();

print $filter->filter('October 2009');

Esto devuelve "2009".

$filter = new Zend_Filter_Digits();

print $filter->filter('HTML 5 for Dummies');

Esto devuelve "5".

No hay opciones adicionales para Zend_Filter_Dir.

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_Dir();

print $filter->filter('/etc/passwd');

Esto devuelve "/etc".

$filter = new Zend_Filter_Dir();

print $filter->filter('C:/Temp/x');

Esto devuelve "C:/Temp".

Las siguientes opciones son soportadas para Zend_Filter_Encrypt y Zend_Filter_Decrypt:

Como estas dos metodologías de cifrado funcionan de forma completamente diferente, el uso de los adaptadores también difiere. Tiene que seleccionar el adaptador que quiere usar al inicializar el filtro.

// Use the Mcrypt adapter
$filter1 = new Zend_Filter_Encrypt(array('adapter' => 'mcrypt'));

// Use the OpenSSL adapter
$filter2 = new Zend_Filter_Encrypt(array('adapter' => 'openssl'));

Para establecer otro adaptador también puede usar setAdapter(), y el método getAdapter() para obtener el adaptador establecido actualmente.

// Use the Mcrypt adapter
$filter = new Zend_Filter_Encrypt();
$filter->setAdapter('openssl');

	Nota
	Cuando no proporciona la opción adapter ni usa setAdapter(), se usará el adaptador Mcrypt por defecto.

Cuando ha instalado la extensión Mcrypt puede usar el adaptador Mcrypt. Si proporciona una cadena en lugar de un array de opciones, esta cadena se usará como clave.

También puede obtener y establecer los valores de cifrado posteriormente con los métodos getEncryption() y setEncryption().

	Nota
	Tenga en cuenta que obtendrá una excepción si la extensión mcrypt no está disponible en su entorno.

	Nota
	También debe tener en cuenta que todos los ajustes se comprobarán al crear la instancia o al llamar a setEncryption(). Si mcrypt detecta un problema con sus ajustes, se lanzará una excepción.

Puede obtener o establecer el vector de cifrado llamando a getVector() y setVector(). Una cadena dada se truncará o rellenará hasta el tamaño de vector necesario del algoritmo usado.

	Nota
	Tenga en cuenta que cuando no está usando un vector propio, debe obtener el vector y almacenarlo. De lo contrario no podrá decodificar la cadena codificada.

// Use the default blowfish settings
$filter = new Zend_Filter_Encrypt('myencryptionkey');

// Set a own vector, otherwise you must call getVector()
// and store this vector for later decryption
$filter->setVector('myvector');
// $filter->getVector();

$encrypted = $filter->filter('text_to_be_encoded');
print $encrypted;

// For decryption look at the Decrypt filter

Para descifrar contenido que fue previamente cifrado con Mcrypt necesita tener las opciones con las que se llamó al cifrado.

Hay una diferencia notable para usted. Cuando no proporcionó un vector en el cifrado, necesita obtenerlo después de cifrar el contenido usando el método getVector() en el filtro de cifrado. Sin el vector correcto no podrá descifrar el contenido.

En cuanto haya proporcionado todas las opciones, el descifrado es tan simple como el cifrado.

// Use the default blowfish settings
$filter = new Zend_Filter_Decrypt('myencryptionkey');

// Set the vector with which the content was encrypted
$filter->setVector('myvector');

$decrypted = $filter->filter('encoded_text_normally_unreadable');
print $decrypted;

	Nota
	Tenga en cuenta que obtendrá una excepción si la extensión mcrypt no está disponible en su entorno.

	Nota
	También debe tener en cuenta que todos los ajustes se comprobarán al crear la instancia o al llamar a setEncryption(). Si mcrypt detecta un problema con sus ajustes, se lanzará una excepción.

Cuando ha instalado la extensión OpenSSL puede usar el adaptador OpenSSL. Puede obtener o establecer las claves públicas posteriormente con los métodos getPublicKey() y setPublicKey(). La clave privada también se puede obtener y establecer con los métodos relacionados getPrivateKey() y setPrivateKey().

// Use openssl and provide a private key
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// of course you can also give the public keys at initiation
$filter->setPublicKey(array(
    '/public/key/path/first.pem',
    '/public/key/path/second.pem'
));

	Nota
	Tenga en cuenta que el adaptador OpenSSL no funcionará si no proporciona claves válidas.

Cuando también quiera codificar las claves, debe proporcionar una frase de paso con el método setPassphrase(). Cuando quiera decodificar contenido que fue codificado con una frase de paso, no solo necesitará la clave pública, sino también la frase de paso para decodificar la clave cifrada.

// Use openssl and provide a private key
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// of course you can also give the public keys at initiation
$filter->setPublicKey(array(
    '/public/key/path/first.pem',
    '/public/key/path/second.pem'
));
$filter->setPassphrase('mypassphrase');

Por último, cuando use OpenSSL necesita dar al receptor el contenido cifrado, la frase de paso cuando haya proporcionado una, y las claves de sobre para el descifrado.

Esto significa que tiene que obtener las claves de sobre después del cifrado con el método getEnvelopeKey().

Así que nuestro ejemplo completo para cifrar contenido con OpenSSL se ve así.

// Use openssl and provide a private key
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// of course you can also give the public keys at initiation
$filter->setPublicKey(array(
    '/public/key/path/first.pem',
    '/public/key/path/second.pem'
));
$filter->setPassphrase('mypassphrase');

$encrypted = $filter->filter('text_to_be_encoded');
$envelope  = $filter->getEnvelopeKey();
print $encrypted;

// For decryption look at the Decrypt filter

// Use openssl and provide a private key
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem',
    'public'  => '/public/key/path/public.pem',
    'package' => true
));

$encrypted = $filter->filter('text_to_be_encoded');
print $encrypted;

// For decryption look at the Decrypt filter

35.2.9.5.2. Comprimir el contenido

Según el valor original, el valor cifrado puede ser una cadena muy grande. Para reducir el valor, Zend_Filter_Encrypt permite el uso de compresión.

La opción compression puede establecerse ya sea con el nombre de un adaptador de compresión, o con un array que establezca todas las opciones deseadas para el adaptador de compresión.

// Use basic compression adapter
$filter1 = new Zend_Filter_Encrypt(array(
    'adapter'     => 'openssl',
    'private'     => '/path/to/mykey/private.pem',
    'public'      => '/public/key/path/public.pem',
    'package'     => true,
    'compression' => 'bz2'
));

// Use basic compression adapter
$filter2 = new Zend_Filter_Encrypt(array(
    'adapter'     => 'openssl',
    'private'     => '/path/to/mykey/private.pem',
    'public'      => '/public/key/path/public.pem',
    'package'     => true,
    'compression' => array('adapter' => 'zip', 'target' => '\usr\tmp\tmp.zip')
));

	Descifrado con los mismos ajustes
	Cuando quiera descifrar un valor que además está comprimido, necesita establecer los mismos ajustes de compresión para el descifrado que para el cifrado. De lo contrario el descifrado fallará.

El descifrado con OpenSSL es tan simple como el cifrado. Pero necesita tener todos los datos de la persona que cifró el contenido. Vea el siguiente ejemplo:

// Use openssl and provide a private key
$filter = new Zend_Filter_Decrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// of course you can also give the envelope keys at initiation
$filter->setEnvelopeKey(array(
    '/key/from/encoder/first.pem',
    '/key/from/encoder/second.pem'
));

	Nota
	Tenga en cuenta que el adaptador OpenSSL no funcionará si no proporciona claves válidas.

Opcionalmente podría ser necesario proporcionar la frase de paso para descifrar las claves en sí mediante el método setPassphrase().

// Use openssl and provide a private key
$filter = new Zend_Filter_Decrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// of course you can also give the envelope keys at initiation
$filter->setEnvelopeKey(array(
    '/key/from/encoder/first.pem',
    '/key/from/encoder/second.pem'
));
$filter->setPassphrase('mypassphrase');

Por último, decodifique el contenido. Nuestro ejemplo completo para descifrar el contenido previamente cifrado se ve así.

// Use openssl and provide a private key
$filter = new Zend_Filter_Decrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// of course you can also give the envelope keys at initiation
$filter->setEnvelopeKey(array(
    '/key/from/encoder/first.pem',
    '/key/from/encoder/second.pem'
));
$filter->setPassphrase('mypassphrase');

$decrypted = $filter->filter('encoded_text_normally_unreadable');
print $decrypted;

Las siguientes opciones son soportadas para Zend_Filter_HtmlEntities:

Vea el siguiente ejemplo del comportamiento por defecto de este filtro.

$filter = new Zend_Filter_HtmlEntities();

print $filter->filter('<');

Zend_Filter_HtmlEntities permite cambiar el estilo de comillas usado. Esto puede ser útil cuando desea dejar sin filtrar las comillas dobles, simples o de ambos tipos. Vea el siguiente ejemplo:

$filter = new Zend_Filter_HtmlEntities(array('quotestyle' => ENT_QUOTES));

$input  = "A 'single' and " . '"double"';
print $filter->filter($input);

El ejemplo anterior devuelve A 'single' and "double". Observe que las comillas 'simples' así como las "dobles" se filtran.

$filter = new Zend_Filter_HtmlEntities(array('quotestyle' => ENT_COMPAT));

$input  = "A 'single' and " . '"double"';
print $filter->filter($input);

El ejemplo anterior devuelve A 'single' and "double". Observe que las comillas "dobles" se filtran mientras que las 'simples' no se ven alteradas.

$filter = new Zend_Filter_HtmlEntities(array('quotestyle' => ENT_NOQUOTES));

$input  = "A 'single' and " . '"double"';
print $filter->filter($input);

El ejemplo anterior devuelve A 'single' and "double". Observe que ni las comillas "dobles" ni las 'simples' se ven alteradas.

Para cambiar u obtener el quotestyle después de la instanciación, se pueden usar respectivamente los dos métodos setQuoteStyle() y getQuoteStyle(). setQuoteStyle() acepta un parámetro $quoteStyle. Se aceptan las siguientes constantes: ENT_COMPAT, ENT_QUOTES, ENT_NOQUOTES

$filter = new Zend_Filter_HtmlEntities();

$filter->setQuoteStyle(ENT_QUOTES);
print $filter->getQuoteStyle(ENT_QUOTES);

Para cambiar u obtener el charset después de la instanciación, se pueden usar respectivamente los dos métodos setCharSet() y getCharSet(). setCharSet() acepta un parámetro $charSet. Vea "http://php.net/htmlentities" para una lista de conjuntos de caracteres soportados.

$filter = new Zend_Filter_HtmlEntities();

$filter->setQuoteStyle(ENT_QUOTES);
print $filter->getQuoteStyle(ENT_QUOTES);

Para cambiar u obtener la opción doublequote después de la instanciación, se pueden usar respectivamente los dos métodos setDoubleQuote() y getDoubleQuote(). setDoubleQuote() acepta un parámetro booleano $doubleQuote.

$filter = new Zend_Filter_HtmlEntities();

$filter->setQuoteStyle(ENT_QUOTES);
print $filter->getQuoteStyle(ENT_QUOTES);

No hay opciones adicionales para Zend_Filter_Int.

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_Int();

print $filter->filter('-4 is less than 0');

Esto devolverá '-4'.

Las siguientes opciones son soportadas para Zend_Filter_LocalizedToNormalized y Zend_Filter_NormalizedToLocalized:

La normalización permite a su usuario introducir información en la notación de su propio idioma, y luego puede almacenar el valor normalizado en su base de datos, por ejemplo. La localización, por otro lado, le permite mostrar información normalizada de forma localizada a su usuario.

	Nota
	Tenga en cuenta que la normalización y la localización no son lo mismo que la traducción. Estos filtros no pueden traducir cadenas de un idioma a otro como cabría esperar con los meses o los nombres de los días.

Los siguientes tipos de entrada pueden normalizarse y localizarse:

Cualquier otra entrada se devolverá tal cual, sin modificarla.

	Nota
	Tenga en cuenta que la salida normalizada siempre se da como cadena. De lo contrario su entorno transferiría automáticamente la salida normalizada a la notación usada por el idioma en el que está configurado su entorno.

Cualquier número dado, como entero, flotante o real, puede normalizarse. Tenga en cuenta que los números en notación científica en realidad no pueden ser manejados por este filtro.

Así que veamos en detalle cómo funciona esta normalización para números:

// Initiate the filter
$filter = new Zend_Filter_LocalizedToNormalized();
$filter->filter('123.456,78');
// returns the value '123456.78'

Supongamos que ha establecido el idioma 'de' como idioma de aplicación en general. Zend_Filter_LocalizedToNormalized tomará el idioma establecido y lo usará para detectar qué tipo de entrada dio usted. En nuestro ejemplo era un valor con precisión. Ahora el filtro le devolverá la representación normalizada de este valor como cadena.

También puede controlar cómo debe verse su número normalizado. Para ello puede dar todas las opciones que también usa Zend_Locale_Format. Para más detalles sobre las opciones disponibles, eche un vistazo a este capítulo de Zend_Locale.

A continuación hay un ejemplo con precisión definida para que pueda ver cómo funcionan las opciones:

// Numeric Filter
$filter = new Zend_Filter_LocalizedToNormalized(array('precision' => 2));

$filter->filter('123.456');
// returns the value '123456.00'

$filter->filter('123.456,78901');
// returns the value '123456.79'

Las entradas de fecha y hora también pueden normalizarse. Todos los valores de fecha y hora dados se devolverán como array, donde cada parte de la fecha se da dentro de su propia clave.

// Initiate the filter
$filter = new Zend_Filter_LocalizedToNormalized();
$filter->filter('12.April.2009');
// returns array('day' => '12', 'month' => '04', 'year' => '2009')

Supongamos que ha establecido el idioma 'de' de nuevo. Ahora la entrada se detecta automáticamente como fecha, y obtendrá un array con claves como resultado.

Por supuesto, también puede controlar cómo se ve su entrada de fecha con las opciones date_format y locale.

// Date Filter
$filter = new Zend_Filter_LocalizedToNormalized(
    array('date_format' => 'ss:mm:HH')
);

$filter->filter('11:22:33');
// returns array('hour' => '33', 'minute' => '22', 'second' => '11')

Cualquier número dado, como entero, flotante o real, puede localizarse. Tenga en cuenta que los números en notación científica en realidad no pueden ser manejados por este filtro.

Así que veamos en detalle cómo funciona la localización para números:

// Initiate the filter
$filter = new Zend_Filter_NormalizedToLocalized();
$filter->filter(123456.78);
// returns the value '123.456,78'

Supongamos que ha establecido el idioma 'de' como idioma de aplicación en general. Zend_Filter_NormalizedToLocalized tomará el idioma establecido y lo usará para detectar qué tipo de salida quiere obtener. En nuestro ejemplo era un valor con precisión. Ahora el filtro le devolverá la representación localizada de este valor como cadena.

También puede controlar cómo debe verse su número localizado. Para ello puede dar todas las opciones que también usa Zend_Locale_Format. Para detalles sobre cómo se usan estas opciones, eche un vistazo a este capítulo de Zend_Locale.

A continuación hay un ejemplo con precisión definida para que pueda ver cómo funcionan las opciones:

// Numeric Filter
$filter = new Zend_Filter_NormalizedToLocalized(array('precision' => 2));

$filter->filter(123456);
// returns the value '123.456,00'

$filter->filter(123456.78901);
// returns the value '123.456,79'

Los valores normalizados de fecha y hora también pueden localizarse. Todos los valores de fecha y hora dados se devolverán como cadena, con el formato definido por el idioma establecido.

// Initiate the filter
$filter = new Zend_Filter_NormalizedToLocalized();
$filter->filter(array('day' => '12', 'month' => '04', 'year' => '2009');
// returns '12.04.2009'

Supongamos que ha establecido el idioma 'de' de nuevo. Ahora la entrada se detecta automáticamente como fecha, y se devolverá en el formato definido por el idioma 'de'.

Por supuesto, también puede controlar cómo se ve su entrada de fecha con las opciones date_format y locale.

// Date Filter
$filter = new Zend_Filter_LocalizedToNormalized(
    array('date_format' => 'ss:mm:HH')
);

$filter->filter(array('hour' => '33', 'minute' => '22', 'second' => '11'));
// returns '11:22:33'

Las siguientes opciones son soportadas para Zend_Filter_Null:

Por defecto este filtro funciona como el método empty() de PHP; en otras palabras, si empty() devuelve un booleano TRUE, entonces se devolverá un valor NULL.

$filter = new Zend_Filter_Null();
$value  = '';
$result = $filter->filter($value);
// returns null instead of the empty string

Esto significa que, sin proporcionar ninguna configuración, Zend_Filter_Null aceptará todos los tipos de entrada y devolverá NULL en los mismos casos que empty().

Cualquier otro valor se devolverá tal cual, sin ningún cambio.

A veces no es suficiente filtrar según empty(). Para ello, Zend_Filter_Null le permite configurar qué tipo se convertirá y cuál no.

Se pueden manejar los siguientes tipos:

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

// converts false to null
$filter = new Zend_Filter_Null(Zend_Filter_Null::BOOLEAN);

// converts false and 0 to null
$filter = new Zend_Filter_Null(
    Zend_Filter_Null::BOOLEAN + Zend_Filter_Null::INTEGER
);

// converts false and 0 to null
$filter = new Zend_Filter_Null( array(
    Zend_Filter_Null::BOOLEAN,
    Zend_Filter_Null::INTEGER
));

// converts false and 0 to null
$filter = new Zend_Filter_Null(array(
    'boolean',
    'integer',
));

También puede dar una instancia de Zend_Config para establecer los tipos deseados. Para establecer los tipos posteriormente use setType().

Las siguientes opciones son soportadas para Zend_Filter_PregReplace:

Para usar este filtro correctamente debe dar dos opciones:

Debe darse la opción match para establecer el patrón que se buscará. Puede ser una cadena para un solo patrón, o un array de cadenas para varios patrones.

Para establecer el patrón que se usará como reemplazo se debe usar la opción replace. Puede ser una cadena para un solo patrón, o un array de cadenas para varios patrones.

$filter = new Zend_Filter_PregReplace(array('match' => '/bob/',
                                            'replace' => 'john'));
$input  = 'Hy bob!';

$filter->filter($input);
// returns 'Hy john!'

Puede usar getMatchPattern() y setMatchPattern() para establecer el patrón de coincidencia posteriormente. Para establecer el patrón de reemplazo puede usar getReplacement() y setReplacement().

$filter = new Zend_Filter_PregReplace();
$filter->setMatchPattern(array('bob', 'Hy'))
       ->setReplacement(array('john', 'Bye'));
$input  = 'Hy bob!";

$filter->filter($input);
// returns 'Bye john!'

Para un uso más complejo, eche un vistazo al capítulo de patrones PCRE de PHP.

Las siguientes opciones son soportadas para Zend_Filter_RealPath:

Para cualquier enlace o nombre de ruta dado se devolverá su ruta absoluta. Las referencias a '/./', '/../' y los caracteres extra '/' en la ruta de entrada se eliminarán. La ruta resultante no tendrá ningún enlace simbólico, ni carácter '/./' o '/../'.

Zend_Filter_RealPath devolverá FALSE en caso de fallo, por ejemplo si el archivo no existe. En sistemas BSD Zend_Filter_RealPath no falla si solo el último componente de la ruta no existe, mientras que otros sistemas devolverán FALSE.

$filter = new Zend_Filter_RealPath();
$path   = '/www/var/path/../../mypath';
$filtered = $filter->filter($path);

// returns '/www/mypath'

A veces es útil obtener también rutas cuando no existen, por ejemplo cuando quiere obtener la ruta real de una ruta que quiere crear. Puede entonces dar un FALSE en la inicialización, o usar setExists() para establecerlo.

$filter = new Zend_Filter_RealPath(false);
$path   = '/www/var/path/../../non/existing/path';
$filtered = $filter->filter($path);

// returns '/www/non/existing/path'
// even when file_exists or realpath would return false

Las siguientes opciones son soportadas para Zend_Filter_StringToLower:

Este es un ejemplo básico:

$filter = new Zend_Filter_StringToLower();

print $filter->filter('SAMPLE');
// returns "sample"

Por defecto solo manejará caracteres del idioma actual de su servidor. Los caracteres de otros conjuntos de caracteres se ignorarían. Aun así, es posible convertirlos también a minúsculas cuando la extensión mbstring está disponible en su entorno. Simplemente establezca la codificación deseada al inicializar el filtro StringToLower. O use el método setEncoding() para cambiar la codificación posteriormente.

// using UTF-8
$filter = new Zend_Filter_StringToLower('UTF-8');

// or give an array which can be useful when using a configuration
$filter = new Zend_Filter_StringToLower(array('encoding' => 'UTF-8'));

// or do this afterwards
$filter->setEncoding('ISO-8859-1');

	Establecer codificaciones incorrectas
	Tenga en cuenta que obtendrá una excepción si quiere establecer una codificación y la extensión mbstring no está disponible en su entorno. También, al intentar establecer una codificación que no está soportada por su extensión mbstring, obtendrá una excepción.

Las siguientes opciones son soportadas para Zend_Filter_StringToUpper:

Este es un ejemplo básico para usar el filtro StringToUpper:

$filter = new Zend_Filter_StringToUpper();

print $filter->filter('Sample');
// returns "SAMPLE"

Al igual que el filtro StringToLower, este filtro maneja solo caracteres del idioma actual de su servidor. El uso de conjuntos de caracteres diferentes funciona igual que con StringToLower.

$filter = new Zend_Filter_StringToUpper(array('encoding' => 'UTF-8'));

// or do this afterwards
$filter->setEncoding('ISO-8859-1');

Las siguientes opciones son soportadas para Zend_Filter_StringTrim:

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_StringTrim();

print $filter->filter(' This is (my) content: ');

El ejemplo anterior devuelve 'This is (my) content:'. Observe que los caracteres de espacio en blanco se han eliminado.

$filter = new Zend_Filter_StringTrim(':');
// or new Zend_Filter_StringTrim(array('charlist' => ':'));

print $filter->filter(' This is (my) content:');

El ejemplo anterior devuelve 'This is (my) content'. Observe que se eliminan los caracteres de espacio en blanco y los dos puntos. También puede proporcionar una instancia de Zend_Config o un array con una clave 'charlist'. Para establecer la lista de caracteres deseada después de la instanciación, use el método setCharList(). getCharList() devuelve los valores establecidos para charlist.

No hay opciones adicionales para Zend_Filter_StripNewLines.

A continuación se muestra un ejemplo básico de uso:

$filter = new Zend_Filter_StripNewLines();

print $filter->filter("This is (my)\n\rcontent: ');

El ejemplo anterior devuelve 'This is (my) content:'. Observe que se han eliminado todos los caracteres de nueva línea.

Las siguientes opciones son soportadas para Zend_Filter_StripTags:

Vea el siguiente ejemplo del comportamiento por defecto de este filtro:

$filter = new Zend_Filter_StripTags();

print $filter->filter('<B>My content</B>');

Como resultado obtendrá el contenido sin etiquetas 'My content'.

Cuando el contenido contiene etiquetas rotas o parciales, todo el contenido siguiente se eliminará. Vea el siguiente ejemplo:

$filter = new Zend_Filter_StripTags();

print $filter->filter('This contains <a href="http://example.com">no ending tag');

Lo anterior devolverá 'This contains', con el resto eliminado.

Zend_Filter_StripTags permite eliminar todas las etiquetas excepto las definidas. Esto puede usarse, por ejemplo, para eliminar todas las etiquetas excepto los enlaces de un texto.

$filter = new Zend_Filter_StripTags(array('allowTags' => 'a'));

$input  = "A text with <br/> a <a href='link.com'>link</a>";
print $filter->filter($input);
// returns: A text with a <a href='link.com'>link</a>

El ejemplo anterior elimina todas las etiquetas excepto el enlace. Proporcionando un array puede establecer varias etiquetas a la vez.

	Advertencia
	No use esta característica para obtener un contenido probablemente seguro. Este componente no reemplaza el uso de un filtro html correctamente configurado.

También es posible eliminar todos los atributos excepto los permitidos de una etiqueta.

$filter = new Zend_Filter_StripTags(array('allowAttribs' => 'src'));

$input  = "A text with <br/> a <img src='picture.com' width='100'>picture</img>";
print $filter->filter($input);
// returns: A text with a <img src='picture.com'>picture</img>

El ejemplo anterior elimina todas las etiquetas excepto img. Además, de la etiqueta img se eliminarán todos los atributos excepto src. Proporcionando un array puede establecer varios atributos a la vez.