Photoshop cs3 cómo hacer iconos planos. Cómo crear iconos planos en Photoshop. lo que crearas

Almacenamiento en búfer de bloques

Un enfoque simplificado almacena en caché el búfer de salida como una sola página. Sin embargo, este enfoque le roba el poder real que brindan las funciones de administración de salida de PHP para mejorar el rendimiento de su sitio al variar la vida útil de su contenido en consecuencia.

Sin duda, algunas partes de la página que envías a tu visitante cambian muy raramente, como el encabezado, el menú y el pie de página. Sin embargo, otras partes, como las tablas que contienen las discusiones del foro, pueden cambiar con bastante frecuencia. El almacenamiento en búfer de salida se puede utilizar para almacenar en caché secciones de una página en archivos separados y luego construir la página a partir de ellas: una solución que elimina la necesidad de realizar consultas repetidas a la base de datos, bucles while, etc. Puede asignar a cada bloque de página una fecha de vencimiento después de la cual se vuelve a crear el archivo de caché, o también puede incluir un mecanismo en su aplicación que eliminará el archivo de caché cada vez que se cambie el contenido almacenado en él.

Aquí hay un ejemplo que demuestra este principio:

Ejemplo 5.3. 3.php (inicio)

/** * Entrada del archivo de caché * @param contenido de cadena – contenido del búfer * @param string filename – nombre de archivo utilizado al crear el archivo de caché * @return void */ función writeCache($contenido, $nombre de archivo) ( $fp = fopen ("./cache/" . $nombre de archivo, "w"); fwrite ($fp, $contenido); fclose ($fp); ) /** * Comprobando archivos de caché * @param string filename – nombre del archivo de caché que se está comprobando * @param int expiry – “antigüedad” máxima del archivo en segundos * @return contenido de caché mixto o falso */ función readCache($nombredearchivo, $expiración) (if (archivo_existe ("./cache/" . $nombredearchivo)) (if ((hora () - $expiración) > filemtime ("./cache/" . $nombre de archivo)) devolver FALSO; $cache = archivo ("./cache/". $nombre de archivo); devolver implosión ( " ", $cache);

Las dos primeras funciones que definimos son escribir caché Y leer caché, se utilizan respectivamente para crear archivos de caché y comprobar su existencia. La función writeCache recibe los datos para almacenar en caché en su primer argumento y el nombre del archivo que se utilizará al crear el archivo de caché. La función readCache recibe el nombre del archivo de caché como primer parámetro, junto con el tiempo en segundos después del cual el archivo de caché debe considerarse obsoleto. Si encuentra que el archivo de caché es válido, el script devolverá su contenido; de lo contrario, devolverá FALSO para indicar que el archivo de caché no existe o está desactualizado.

En este ejemplo utilicé un enfoque procesal. Sin embargo, no recomiendo hacer esto en la práctica, ya que terminará en un código muy desordenado (consulte las soluciones posteriores para obtener una mejor alternativa) y probablemente causará problemas de bloqueo de archivos (por ejemplo, qué sucede cuando alguien accede al caché mientras se está ejecutando). ¿actualizado? ).

Sigamos con este ejemplo. Una vez que se ha iniciado el almacenamiento en búfer de salida, comienza el procesamiento. El script primero llama a readCache para ver si el archivo 3_header.cache existe y contiene el encabezado de la página: el encabezado HTML y el comienzo del cuerpo. Usamos la función de fecha de PHP para generar la hora en que se generó realmente la página, por lo que verá los distintos archivos de caché en acción cuando se represente la página.

Ejemplo 5.4. 3.php (continuación)

// Comenzar a almacenar en buffer la salida ob_start(); // Procesar el encabezado if (!$header = readCache("3_header.cache", 604800) ) ( // ¿Salir el encabezado?>"-//W3C//DTD XHTML 1.0 Estricto//ES" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/1999/xhtml"> "texto/html; juego de caracteres=windows-1251" /> Hora de creación del encabezado:

¿Qué sucede cuando no se encuentra el archivo de caché? Parte del contenido se genera y se asigna a una variable usando ob_get_contents, después de lo cual la función ob_clean borra el búfer. Esto nos permite capturar la salida pieza por pieza y relacionarla con archivos de caché individuales usando writeCache. El título de la página ahora se almacena como un archivo que se puede utilizar sin nuestra intervención para reconstruir la página. Volvamos al principio de la declaración condicional por un segundo. Cuando llamamos a readCache, le pasamos una vida útil de caché de 604800 segundos (una semana), readCache usa el tiempo de modificación del archivo de caché para determinar si el archivo de caché aún es válido.

Para el contenido (cuerpo) de la página seguiremos utilizando el mismo proceso. Sin embargo, esta vez, cuando llamemos a readCache, usaremos una vida útil de caché de cinco segundos, el archivo de caché se modificará cada vez que tenga más de 5 segundos:

Ejemplo 5.5. 3.php (continuación)

// Procesar el cuerpo de la página if (!$cuerpo = readCache("3_body.cache", 5) ) (echo "Tiempo de creación del cuerpo: ". fecha ("H:i:s" ). "
" ; $cuerpo = ob_get_contents () ; ob_clean () ; writeCache($cuerpo, "3_body.cache" ); )

El pie de página se puede modificar efectivamente de la misma manera que el encabezado. Después de esto, el almacenamiento en búfer de salida se detiene y se muestra el contenido de tres variables que contienen datos de la página:

Ejemplo 5.6. 3.php (fin)

// Maneja el pie de página if (!$footer = readCache("3_footer.cache" , 604800 ) ) ( ?> Hora de creación del pie de página:


// dejar de almacenar en buffer ob_end_clean(); // Mostrar contenido de la página eco $ encabezado. $cuerpo. $pie de página;

El resultado final se parece a esto:

Hora de creación del encabezado: 17:10:42 Hora de creación del cuerpo: 18:07:40 Hora de creación del pie de página: 17:10:42

El encabezado y pie de página se actualizan semanalmente, mientras que el cuerpo se modifica cuando tiene más de 5 segundos.

El diagrama de bloques de la Figura 5.1 resume la metodología de almacenamiento en búfer de bloques.

Figura 5.1. Diagrama de bloques del almacenamiento en búfer de salida de bloque

Búfers anidados

Puede anidar un búfer dentro de otro prácticamente de forma indefinida simplemente llamando a ob_start repetidamente. Esto puede resultar útil si tiene muchas operaciones que utilizan el búfer de salida, por ejemplo algunas que detectan mensajes de error de PHP y otras que se ocupan del almacenamiento en caché. Debe asegurarse de que se llame a ob_end_flush u ob_end_clean cada vez que se utilice ob_start.

¿Cómo puedo implementar un sistema de almacenamiento en caché del lado del servidor simple?

Ahora que entendemos las ideas detrás del almacenamiento en búfer de salida, es hora de ver cómo podemos poner este proceso en acción de una manera que sea fácil de mantener. Para hacer esto, usaremos un poco de ayuda de PEAR::CacheLite (en los ejemplos aquí se usó la versión 1.1).

caché_lite

Como dije, con el fin de hacer que su código sea más fácil de mantener y tener un mecanismo de almacenamiento en caché confiable, es aconsejable asignar la responsabilidad de la lógica del caché a clases en las que confíe. Cache_Lite es una biblioteca de almacenamiento en caché potente pero fácil de usar que se encarga de tareas como bloquear temporalmente archivos de caché, crearlos y validarlos, administrar el búfer de salida y almacenar en caché directamente el resultado de una función o método de clase. La razón principal para elegir esta biblioteca es la integración relativamente simple de Cache_Lite en una aplicación existente, que solo requiere cambios menores en el código.

Cache_Lite consta de tres clases principales. La primera es la clase base Cache_Lite, que es responsable únicamente de crear y leer archivos de caché y no almacena en búfer la salida. Esta clase se puede utilizar sola en los casos en los que no es necesario utilizar el almacenamiento en búfer de salida, como cuando se guarda el resultado del análisis de una plantilla PHP mediante un script. Los ejemplos que se muestran aquí no utilizan la clase Cache_Lite directamente y demuestran el uso de las otras dos clases. Cache_Lite_Function se utiliza para llamar a una función o método de clase y luego almacenar en caché los resultados. Esto puede resultar útil, por ejemplo, para almacenar en caché el resultado de una consulta en My SQL?. La clase Cache_Lite_Output utiliza funciones de control de salida de PHP para interceptar datos generados por un script y almacenarlos en archivos de caché. Esto le permite realizar las mismas tareas que la solución anterior.

Aquí hay un ejemplo que le mostrará cómo podría usar Cache_Lite para realizar la tarea que cubrimos en la parte anterior. Para considerar cualquier uso de Cache_Lite, primero debemos configurarlo (crear una serie de parámetros) que determinarán el comportamiento de la clase. Los veremos con más detalle a continuación, pero por ahora, tenga en cuenta que su script debe tener permisos de lectura y escritura en el directorio cacheDir.

Ejemplo 5.7. 4.php (inicio)

// Conecta la clase de salida PEAR::Cache_Lite require_once "Caché/Lite/Output.php"; // Definir la configuración para Cache_Lite$opciones = matriz ( "cacheDir" => "./cache/" , "writeControl" => "true", ​​"readControl" => "true", ​​"readControlType" => "md5"); // Crea un objeto de la clase Cache_Lite_Output

Para cada parte de la salida de su secuencia de comandos que desee almacenar en caché, debe establecer la duración de la caché en segundos. este tiempo determina cuánto tiempo se recuperarán los datos del caché. Pasado este tiempo, los datos del fichero se actualizarán. A continuación, llamamos al método start(), disponible sólo en la clase Cahce_Lite_Output, que permite el almacenamiento en búfer de salida. Pasamos 2 parámetros al método: el primero es el identificador del archivo de caché, el segundo es el grupo (tipo de caché). El parámetro "grupo" le permite combinar varias plantillas, esto le permite realizar acciones grupales, por ejemplo, eliminar todos los archivos de caché de un grupo. Una vez finalizada la salida de la pieza que necesitamos, debemos llamar al método stop(). Este método detendrá el almacenamiento en búfer y guardará el contenido del búfer en un archivo.

Ejemplo 5.8. 4.php (continuación)

// Establece la duración del caché para esta parte$caché ->setLifeTime (604800); // Iniciar el almacenamiento en búfer para la sección denominada encabezado // y lo ponemos en el grupo Estático if (!$cache ->start ("encabezado", "Estático")) ( ?>"-//W3C//DTD XHTML 1.0 Estricto//ES" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> "http://www.w3.org/1999/xhtml"> "texto/html; juego de caracteres=windows-1251" />

Ejemplo de PEAR::Cache_Lite

Almacenar en caché el cuerpo principal de la salida (cuerpo) y la parte inferior (pie de página) es similar a almacenar en caché el encabezado. Tenga en cuenta que volvemos a configurar la vida útil de la caché para cada parte posterior.

Ejemplo 5.9. 4.php (continuación)

$caché ->setLifeTime (5); if (!$cache ->start ("cuerpo", "Dinámico")) (echo "Tiempo de creación del cuerpo: ". fecha ("H:i:s" ). "
" ; $cache ->end () ; ) $cache ->setLifeTime (604800) ; if (!$cache ->start ("pie de página", "Estático") ) ( ?> Hora de creación inferior:


fin(); )

Cuando vea esta página, Cache_Lite creará los siguientes archivos en el directorio de caché:

./cache/cache_Static_header ./cache/cache_Dynamic_body ./cache/cache_Static_footer

Si solicita la misma página más adelante, el código anterior le mostrará el contenido de estos archivos, por supuesto, si su vida útil aún no ha expirado.

• Proteger archivos en caché.
• Asegúrese de que el directorio donde almacena los archivos de caché no sea de acceso público. de lo contrario, los visitantes de su sitio podrán hacer más de lo que a usted le gustaría que hicieran.

Configuración de caché_Lite

Al llamar a Cache_Lite (o cualquiera de sus subclases, como Cache_Lite_Output), existen muchas formas de controlar su comportamiento. Todos los parámetros deben colocarse en una matriz y pasarse al constructor:

Ejemplo 5.10. 4.php (fin)

// Establecer la configuración para Cache_Lite$opciones = matriz ( "cacheDir" => "./cache/", "writeControl" => TRUE, "readControl" => TRUE, "readControlType" => "md5"); // Crea un objeto Cache_Lite_Output$caché = nuevo Cache_Lite_Output($opciones);

En la versión actual de la clase (1.1), las siguientes configuraciones están disponibles:

• cacheDir: este es el directorio donde se colocarán los archivos de caché. El valor predeterminado es el directorio donde se ejecuta el script.
• almacenamiento en caché: esta opción habilita o deshabilita las capacidades de Cache_Lite. Por ejemplo, si tiene muchas solicitudes a Cache_Lite y durante la depuración desea desactivar el almacenamiento en caché, configúrelo en FALSO. El valor predeterminado es VERDADERO.
• duración: este parámetro contiene la duración de la caché predeterminada (en segundos). Puede cambiar el valor llamando al método setLifeTime(). El valor predeterminado es 3600 (una hora).
• fileNameProtection: si esta opción está habilitada, Chache_Lite utilizará la codificación MD5 para generar el nombre del archivo de caché. Esto le permite utilizar cualquier carácter en los nombres de los archivos y grupos de caché, incluso aquellos prohibidos por el sistema de archivos. Esta configuración debe estar habilitada cuando usa Cache_Lite_Function. El valor predeterminado es VERDADERO (habilitado).
• fileLocking: este parámetro habilita mecanismos para bloquear un archivo de caché mientras se escriben datos en él. El valor predeterminado es VERDADERO (habilitado).
• writeControl: verifica que el archivo de caché se escribió correctamente inmediatamente después de finalizar la escritura. En caso de error, arroja PEAR:Error. Esta característica permite que su secuencia de comandos sobrescriba el archivo de caché nuevamente, pero lo ralentiza. El valor predeterminado es VERDADERO (habilitado).
• readControl: antes de leer un archivo de caché, comprueba si está dañado. Cache_Lite coloca un valor de longitud de archivo en el archivo que se puede usar para monitorear su integridad. También existe un mecanismo alternativo para comprobar la integridad de los archivos. Está habilitado por el parámetro readControlType. Estos mecanismos reducen un poco la velocidad, pero ayudan a garantizar que sus usuarios vean una página intacta. El valor predeterminado es VERDADERO (habilitado).
• readControlType: este parámetro determina el tipo de mecanismo de lectura de archivos de caché. Mecanismos disponibles: verificación de redundancia cíclica ("crc32" - valor predeterminado): usa la función PHP crc32, hash "MD5": usa la función PHP md5 o una verificación de longitud simple: "strlen". Tenga en cuenta que este mecanismo no está destinado a proteger los archivos de caché para que no puedan acceder directamente usuarios no autorizados. Esta es sólo una forma de determinar si un archivo está dañado o no.

pearErrorMode: habilita el método PEAR para devolver errores. El valor predeterminado es CACHE_LITE_PEAR_RETURN: devuelve el objeto /#c#?PEAR::Error.

• MemoryCaching: si esta opción está habilitada, cada vez que llama al caché para escribir en un archivo, se escribe en la matriz Cache_Lite. saveMemoryCachingState y getMemoryCachingState se utilizan para acceder al caché almacenado en la memoria entre solicitudes. La ventaja de este método es que el contenido de la caché se puede almacenar en un solo archivo, lo que reduce la cantidad de ciclos de lectura/escritura del disco. El caché se restaura directamente en una matriz a la que puede acceder su script. En nuestros ejemplos usaremos el mecanismo Cache_Lite habitual, pero es posible que quieras experimentar con esta opción más adelante si tienes un sitio muy grande. El valor predeterminado es VERDADERO (deshabilitado).
• onlyMemoryCaching: si habilita esta opción, solo se utilizará el mecanismo de almacenamiento en caché en memoria. El valor predeterminado es VERDADERO (deshabilitado).

MemoryCachingLimit: este parámetro especifica el límite en la cantidad de archivos de caché que se pueden almacenar en una matriz en memoria. Cuanto mayor sea el número de archivos, más memoria se consumirá. Por tanto, definir un límite es una muy buena idea. Por supuesto, esto no afecta el tamaño del archivo de caché, ya que uno o dos archivos masivos no crearán ningún problema. el valor predeterminado es 1000.

Borrar caché

Cahce_Lite contiene un mecanismo exitoso para determinar la vida útil de los archivos de caché, lo que crea una buena base para la seguridad de sus archivos y su actualización oportuna. Sin embargo, hay ocasiones en las que necesita actualizar su archivo de caché inmediatamente. Para tales casos, existen los métodos remove() y clean(). El método remove() está diseñado para eliminar un archivo de caché específico. requiere el ID de la caché y el nombre del grupo al que pertenece el archivo. El siguiente ejemplo eliminará el archivo de caché del cuerpo del ejemplo anterior:

$cache ->remove ("cuerpo", "Dinámico");

El método clean() nos permite eliminar todos los archivos de nuestro directorio cuando se llama sin parámetros. Si pasa el nombre de un grupo como parámetro, se eliminarán todos los archivos incluidos en este grupo. Si queremos eliminar el encabezado y la parte inferior, debemos enviar comandos similares a estos:

$cache ->limpiar ("Estático");

Los métodos remove() y clean() obviamente deben llamarse en respuesta a eventos dentro de la aplicación. Por ejemplo, si tiene un foro, probablemente debería eliminar el archivo de caché si algún usuario publica un mensaje nuevo. Aunque esta solución parece buena, puede implicar algunos cambios de código. Si tiene un script principal que se conecta a cada página de la aplicación que un visitante podría ver, puede simplemente observar los eventos entrantes, como la variable $_GET["newPost"], eliminando los archivos de caché necesarios. Esto le permitirá crear un mecanismo de gestión de caché centralizado. Incluso podría incluir este código en php.ini (consulte la descripción de la configuración auto_prepend_file).

Llamadas a funciones de almacenamiento en caché

En el Capítulo 2, XML, analizamos el acceso remoto a servicios web utilizando SOAP y XML-RPC. Debido a que se puede acceder a los servicios web a través de la red, a menudo es una buena idea almacenar en caché el resultado para que pueda ejecutarse localmente en lugar de repetir la misma consulta lenta una y otra vez. En el caso más simple, podríamos usar sesiones PHP, que cubrimos en ese capítulo, pero como esta solución se basa en la frecuencia de los visitantes, abrir una solicitud para cada visitante aún sería lento. En tales casos, Cache_Lite puede resultar muy útil.

• PEAR usa Cache_Lite
• El instalador web de PEAR (lea el Apéndice D, cómo trabajar con PEAR) utiliza Cache_Lite para almacenar en caché las solicitudes XML-RPC enviadas al servidor web de PEAR.

En la sección llamada “¿Cómo consumo servicios web SOAP con PHP?”, escribimos un cliente para servir un servicio web SOAP basado en su archivo WSDL; Este servicio proporciona información meteorológica a todos los aeropuertos del mundo. Aquí está el código que recibe datos del servidor remoto:

$paises = $stationInfo ->listCountries () ;

$país = $stationInfo ->searchByCountry ($_GET [ "país" ] );

En ambos casos, estas llamadas corresponden a una solicitud de datos a través de la red. Usando Cache_Lite, podríamos almacenar en caché los datos devueltos por el servicio y poder reutilizarlos. Esto evitaría conexiones de red adicionales innecesarias y aumentaría significativamente la velocidad de ejecución. Tenga en cuenta que aquí solo estamos viendo el código relacionado con nuestro tema. Primero habilitamos Cache_Lite_Function:

Ejemplo 5.11. 5.php (inicio)

// Incluir PEAR::Cache_Lite_Function require_once "Caché/Lite/Function.php";

Ejemplo 5.12. 5.php (continuación)

// Establecer parámetros para Cache_Lite_Function // ADVERTENCIA: fileNameProtection = ¡VERDADERO!$opciones = matriz ( "cacheDir" => "./cache/", "fileNameProtection" => TRUE, "writeControl" => TRUE, "readControl" => TRUE, "readControlType" => "strlen", "defaultGroup" => "JABÓN" ); // Crea un objeto de la clase Cache_Lite_Function$caché = nueva Cache_Lite_Function($opciones);

Es importante que el parámetro fileNameProtection esté establecido en TRUE. Este es el valor predeterminado, pero lo configuré manualmente específicamente para enfatizar su importancia. Establecer esta opción en FALSO dará como resultado un nombre de archivo no válido, por lo que no se producirá el almacenamiento en caché.

Ejemplo 5.13. 5.php (continuación)

$paises = $cache ->call( "stationInfo->listCountries" );

Ejemplo 5.14. 5.php (fin)

$país = $caché ->llamar ( "stationInfo->searchByCountry",$_GET ["país" ]) ;

Si se realiza una solicitud por primera vez, Cache_Lite_Function almacena los resultados como una matriz serializada en un archivo de caché (no tiene que preocuparse por eso) y este archivo se usará para solicitudes futuras hasta que caduque su vida útil. setLifeTime se puede utilizar para determinar cuánto tiempo vivirá un archivo de caché antes de actualizar su información. El valor predeterminado es 1 hora (3600 segundos).

En general, Cache_Lite proporciona un sistema único y fácil de usar para resolver cualquier problema relacionado con el almacenamiento en caché. Dado que el siguiente nivel son los sitios con tráfico particularmente alto, deberías explorar PEAR::Cache, que es el hermano mayor de Cache_Lite. También proporciona capacidades de almacenamiento en caché mejoradas, como el almacenamiento en caché de memoria compartida como alternativa al almacenamiento en caché de archivos, o la extensión PHP Msession para ayudar a almacenar datos en una sesión equilibrada, que es especialmente útil en servidores WEB equilibrados. Proporcionaré otros materiales sobre PEAR::Cache al final de este artículo. Cache_Lite, sin embargo, ofrece funciones más que suficientes y satisface las necesidades de la mayoría de los sitios.

¿Cómo puedo administrar el almacenamiento en caché del lado del cliente usando PHP?

Ahora que hemos visto las opciones para anular el almacenamiento en caché del lado del cliente y cómo se puede implementar el almacenamiento en caché del lado del cliente, es hora de ver un mecanismo que nos permitirá controlar el caché del lado del cliente usando PHP. Este enfoque solo funcionará si está utilizando PHP con un servidor Apache, ya que usaremos la función getallheaders para obtener los encabezados enviados por el navegador. esta función sólo funciona en Apache.

Nuevos nombres de funciones

Si está utilizando PHP 4.3.0 con Apache, los encabezados HTTP están disponibles a través de las funciones apache_request_headers y apache_response_headers. La función getallheaders se ha convertido en un alias para la nueva función apache_request_headers.

El mecanismo para trabajar con la caché del navegador web es nuevamente HTTP. Muchos encabezados participan en la instrucción a los navegadores web y servidores proxy para que almacenen en caché una página de forma independiente, una situación complicada por el hecho de que algunos de ellos solo están disponibles con HTTP 1.1.

Comprobación de encabezados HTTP en su navegador

¿Una herramienta simple pero muy conveniente para verificar los encabezados de solicitudes y respuestas son Live Http Headers? – complemento para el navegador Mozilla. Es importante saber exactamente qué encabezados envía su secuencia de comandos, especialmente cuando se trata de encabezados de almacenamiento en caché HTTP.

Para simplificar, solo consideraremos los encabezados de almacenamiento en caché HTTP 1.0, a saber, Expires, Last-Modified y If-Modified-Since, así como el código de estado HTTP 304 (No modificado).

Otros encabezados disponibles con HTTP 1.1, como Cache-Control y ETag, están destinados a proporcionar un mecanismo avanzado que se puede utilizar junto con el estado de la sesión web; en otras palabras, la versión de una página determinada mostrada a un visitante no autorizado puede ser significativamente diferente de la que se muestra a un usuario autorizado. Los encabezados HTTP 1.1 se agregaron originalmente para permitir que dichas páginas se almacenen en caché.

Caducidad de la vida útil de la página

El encabezado más fácil de usar es el encabezado Expire, que establece una fecha (posiblemente en el futuro) en la que caducará la página. Hasta este punto, el navegador web puede utilizar la versión almacenada en caché de la página.

Ejemplo 5.15. 6.php

/** * Envía el encabezado HTTP 1.0 Expires. * @param int número de segundos hasta que expire el tiempo */ función setExpires($expires) ( encabezado ("Expires: " . gmdate ("D, d M Y H:i:s", hora () + $expires ). "GMT" ); ) // Establecer el encabezado del tiempo de vencimiento Expires setExpires(10); // Mostrar eco "Esta página se autodestruirá en 10 segundos.
" ; eco "Ahora ". gmdate("H:i:s") . " GMT
" ; echo """>Ver de nuevo
" ;

La función setExpires envía un encabezado HTTP Expires con un tiempo futuro especificado en segundos. El ejemplo anterior muestra la hora GMT actual y muestra un enlace que le permite volver a la página. Usando el botón Actualizar de su navegador, puede decirle al navegador que desea actualizar su caché. Usando el enlace verás que la hora solo cambia una vez cada 10 segundos.

Fechas y horas en HTTP

Las fechas en HTTP siempre se calculan en relación con la hora media de Greenwich (GMT). La función PHP gmdate es exactamente la misma función que date, excepto que compensa automáticamente GMT según el reloj del sistema y la configuración regional de su servidor.

Cuando el navegador encuentra el encabezado Expires, almacena en caché la página. Todas las solicitudes de página posteriores realizadas antes del tiempo de vencimiento especificado utilizan la versión almacenada en caché de la página y no se realiza ninguna solicitud al servidor web.

El encabezado Expires es fácil de implementar, pero en la mayoría de los casos, a menos que sea una persona muy organizada, no tiene forma de saber exactamente cuándo se actualiza una página determinada de su sitio. Dado que el navegador sólo se comunicará con el servidor después de que la página se haya vuelto obsoleta, no hay forma de decirle al navegador que una página en su caché está obsoleta. También pierde algo de tráfico en su sitio web porque el navegador no se comunica con el servidor cuando solicita una página almacenada en caché.

Hora de cambio de página

Es más práctico utilizar los encabezados Last-Modified y If-Modified-Since disponibles en HTTP 1.0. Técnicamente conocido como realizar una solicitud GET condicional, devuelve cualquier contenido según la condición del encabezado de solicitud If-Modified-Since.

Al utilizar este método, debe enviar un encabezado Última modificación cada vez que se acceda a su script PHP. La próxima vez que el navegador solicite la página, enviará un encabezado If-Modified-Since que contiene el tiempo que su script puede usar para determinar si la página se actualizó desde la última solicitud. Si este no es el caso, su secuencia de comandos envía un código de estado HTTP 304 para indicar que la página no ha cambiado, sin imprimir el contenido de la página.

El ejemplo más simple de un GET condicional es bastante complicado; una herramienta bastante conveniente para mostrar cómo funciona es PEAR::Cache_Lite. Sin embargo, esto no debe considerarse un ejemplo de almacenamiento en caché del servidor; simplemente implica que un archivo se modifica periódicamente.

Ejemplo 5.16. 7.php (inicio)

// Conectar PEAR::Cache_Lite require_once "Caché/Lite.php"; // Definir la configuración de Cache_Lite$opciones = matriz( "cacheDir" => "./cache/" ); // Inicializa Cache_Lite$caché = nuevo Cache_Lite($opciones); // Algunos datos ficticios para almacenar$id = "MiCaché" ; // Inicializa el caché si la página se solicita por primera vez if (!$cache ->get ($id) ) ( $cache ->save ("Dummy", $id ); ) // Aleatorizador...$aleatorio = matriz (0, 1, 1); barajar ($aleatorio); // Actualización aleatoria de caché if ($aleatorio [ 0 ] == 0 ) ( $cache ->save ("Dummy", $id); ) // Obtener la hora de la última modificación del archivo de caché$lastModified = filemtime ($cache ->_file); < v6 отдаёт их неправильно) encabezado ("Última modificación: " . gmdate ("D, d M Y H:i:s", $última modificación). " GMT" );<= $modifiedSince ) { header ("HTTP/1.1 304 Not Modified" ) ; exit () ; } echo "Сейчас " . gmdate ("H:i:s" ) . $modificadoDesde = 0 ; ) si ($última modificación
" "GMT
" ;

; eco """>Actualizar

Asegúrese de utilizar el enlace Actualizar cuando ejecute este ejemplo (al hacer clic en Actualizar normalmente se borrará la memoria caché de su navegador). Si hace clic en el enlace repetidamente, eventualmente se modificará el caché, su navegador eliminará la versión del caché y almacenará en él la nueva página proporcionada por PHP.

En el ejemplo anterior, utilizamos PEAR::Cache_Lite para crear un archivo de caché modificado aleatoriamente. Establecemos la hora de modificación del archivo de caché con esta línea:

$lastModified = filemtime ($cache ->_file);

Técnicamente hablando, esto es un truco porque la variable $_file de la clase PEAR::Cache_Lite debe ser privada. Sin embargo, nos vemos obligados a usarlo para obtener el nombre del archivo de caché y conocer su hora de modificación.

Luego, utilizando la hora de modificación del archivo de caché, enviamos el encabezado Última modificación. Necesitamos enviar esto para cada página servida para obligar al navegador a enviarnos un encabezado If-Modified-Since con cada solicitud.// Emitir encabezado HTTP de última modificación

El uso de la función getallheaders garantiza que obtengamos todos los encabezados entrantes de PHP como una matriz. Luego tenemos que verificar que el encabezado If-Modified-Since realmente existe; si existe, tenemos que manejar el caso especial de versiones anteriores de Mozilla (inferiores a la versión 6) que agregaron un campo adicional al final (desviándose de la especificación). ) al encabezado If-Modified-Desde. Usando la función PHP strtotime, obtenemos la marca de tiempo de la fecha que nos pasó el navegador. Si no existe tal encabezado, asignamos una marca de tiempo de cero, lo que obliga a PHP a brindarle al visitante la última versión de la página.

// Obtener encabezados de solicitud del cliente - solo Apache$solicitud = getallheaders(); if (isset ($solicitud [ "Si-Modificado-Since" ] ) ) ( // Dividir si-modificado-desde (Netscape< v6 отдаёт их неправильно) $modifiedSince = explotar (";" , $request [ "If-Modified-Since" ] ); // Convierte la solicitud If-Modified-Since del cliente en una marca de tiempo$modificadoSince = strtotime ($modificadoSince [ 0 ] ); ) demás ( // Establece el tiempo de modificación en cero$modificadoDesde = 0 ; )

Finalmente, verificamos si el caché se ha modificado desde la última vez que el visitante recibió esta página. Si este no es el caso, simplemente enviamos una respuesta No modificado en el encabezado y dejamos de ejecutar el script, sin cargar el enlace de datos y ahorrando tiempo de CPU al indicarle al navegador que muestre una versión en caché de la página.

// Compara la hora de la última modificación del contenido con la caché del cliente si ($última modificación<= $modifiedSince ) { // ¡Descarga el canal de transmisión de datos! encabezado ("HTTP/1.1 304 no modificado"); salida(); )

Si combina el enfoque de hora de última modificación con un valor de tiempo que ya está disponible en su aplicación (por ejemplo, la hora del artículo de noticias más reciente o la hora de vencimiento del sistema de almacenamiento en caché del lado del servidor que vimos en la última solución) , puede aprovechar la caché del navegador web y aliviar el canal de transmisión de datos, ahorrando tráfico de información desde su sitio siempre que sea posible y mejorando su rendimiento percibido.

Tenga cuidado al probar cualquier almacenamiento en caché realizado con este estilo; si lo hace incorrectamente, podría provocar que sus visitantes siempre tengan copias desactualizadas de su sitio.

Enlaces adicionales

• Solicitud GET con condición (GET condicional)
• Seguimiento de contenido en sitios dinámicos

La mayoría de los servidores web pueden manejar una cantidad suficiente de tráfico. Quizás me estés preguntando: ¿Por qué entonces usar un caché en nuestros sitios usando PHP? El servidor web Apache puede servir una gran cantidad de archivos, pero al mismo tiempo, todos estos archivos deben ser estáticos. Los scripts se procesan en el servidor web, se interpretan y luego el archivo HTML generado se envía al navegador del cliente. Esto sucede en el servidor web y con la participación del intérprete PHP, y esto requiere memoria adicional además de simplemente enviar el archivo HTML al cliente web. Imagínese lo que sucederá si ejecuta un análisis de la página de un sitio web que se ejecuta en WordPress y cuánta memoria del servidor consumirá.

¡La web no se trata sólo de visitantes en vivo!

Si su sitio tiene pocos visitantes, entonces el servidor web debería poder procesar y mostrar todas las páginas a los visitantes sin ningún problema. Mientras todo vaya bien, tanto tú como tus visitantes estaréis contentos. Pero, ¿qué pasa si algún robot accede a su sitio? El peor resultado de esto es que puede ralentizar "antinaturalmente" o incluso causar un mal funcionamiento de su sitio, ¡así como de otros sitios ubicados en el mismo servidor!

WordPress Super Cache, un complemento de WP imprescindible

Incluso si tu blog no tiene muchos visitantes, debes instalar el complemento Super Cache de WordPress. ¡Este complemento funciona en la mayoría de los servidores y puede salvarle la vida a su sitio web! WordPress utiliza muchas consultas de bases de datos para mostrar una sola página a un visitante del sitio. Cada conexión a la base de datos necesita memoria y utilizará recursos de la CPU. Al utilizar el complemento Super Cache, las páginas que se visualizan no utilizarán la base de datos, sino que se almacenarán en la memoria caché y su servidor podrá manejar mucho más tráfico.

Funciones de caché para sitios PHP

Hay muchas formas de utilizar el caché en su sitio. Hay módulos de caché y también puede crear una versión de caché de cada página del sitio utilizando algún código PHP. La solución que elijas depende de la situación, la aplicación y el tipo de hosting que utilices.

Proyecto eAccelerator

Si puede configurar un servidor web y tener privilegios de root, debería probar eAccelerator. Funciona como una extensión para PHP y puede crear una versión en caché de sus scripts. Probé eAccelerator en varios servidores y realmente me gustó cómo funciona esta extensión.

Almacenamiento en caché en PHP

Si está buscando una forma de almacenar en caché páginas individuales de su sitio, debería intentar lo siguiente. El fragmento de código proporcionado podrá guardar los datos mostrados como una página HTML estática. Leerá/escribirá y generará una versión en caché de la página.

// la función recibe y escribe datos en un archivo function get_and_write($url, $cache_file) ( $string = file_get_contents($url); $f = fopen($cache_file, "w"); fwrite ($f, $string, strlen ($string)); fclose($f); return $string ) // función que lee y coloca datos en la variable de salida function read_content($path) ( $f = fopen($path, "r"); $buffer = ""; while(!feof($f)) ( $buffer .= fread($f, 2048); ) fclose($f); return $buffer) $cache_file = "/home/user/public_html/ caché /cache.page.php"; $url = "http://www.dominio.com/página.php"; if (file_exists($cache_file)) ( // ¿hay un archivo de caché? $timedif = (time() - filemtime($cache_file)); // ¿cuándo se creó el archivo? if ($timedif< 3600*24) { // получить новый файл $html = read_content($cache_file); // считать содержимое кэша } else { // создать новый кэш файл $html = get_and_write($url, $cache_file); } } else { // нету файла? создать новый кэш файл $html = get_and_write($url, $cache_file); } echo $html; exit;

Este código es muy simple, pero no dinámico. Para que este ejemplo funcione, debe crear una lista de archivos de caché y URL. A continuación se muestran algunas reglas mod_rewrite según la estructura de archivos del sitio.

En este caso, usamos parte de la URL y pasamos esta cadena como una variable usando la solicitud. Aquí hay algunos ejemplos de URL:

Http://dominio.com/page/ajax-tutorial http://dominio.com/page/php-parsing http://dominio.com/page/jquery-plugin

En el archivo .htaccess aplicamos la siguiente regla:

RewriteEngine en RewriteRule ^page\/(*)$ /page.php?pageurl=$1 [L]

Cuando se comunique con la dirección "página/" haremos una pequeña verificación. En el archivo page.php, escribiremos un fragmento de código para generar automáticamente un caché de las versiones de la página.

If (!empty($_GET["pageurl"]) && preg_match("/^*$/", $_GET["pageurl"])) ( $cache_file = "/home/user/public_html/cache/cache-" .$_GET["pageurl"]..php"; $url = "http://www.domain.com/page.php?page=".$_GET["pageurl"] ) else ( encabezado (" HTTP/ 1.1 301 movido permanentemente"); encabezado("Ubicación: ".$url); salir; )

Este artículo está terminado; pronto se publicarán reseñas muy interesantes que estoy preparando. Así que a seguir el blog.

PD El código que utilicé en la descripción es sólo un ejemplo y debes cambiarlo para que funcione en tu situación específica.

Para optimizar el trabajo con la red, se utiliza un mecanismo para guardar los documentos una vez recibidos a través de HTTP en una caché con el fin de reutilizarlos sin contactar con el servidor de origen. Un documento guardado en la caché estará disponible la próxima vez que se acceda a él, sin necesidad de descargarlo del servidor de origen, lo que tiene como objetivo aumentar la velocidad de acceso del cliente al mismo y reducir el consumo de tráfico de la red.

Los cachés en sí son de dos tipos: locales y compartidos. Local es un caché almacenado directamente en el disco del cliente, creado y administrado por su navegador. General: caché del servidor proxy de una organización o proveedor y puede constar de uno o más servidores proxy. Un caché local está presente, probablemente en todos los navegadores; una parte importante de las personas que navegan por Internet utilizan los comunes. Y si una pequeña parte de los sitios ahora se evalúa en función del consumo de tráfico, entonces la velocidad de carga es un criterio importante que debe tenerse en cuenta al desarrollar su proyecto web.

Para páginas dinámicas creadas como resultado de un programa PHP, el almacenamiento en caché parecería perjudicial. El contenido de la página se forma a petición del usuario en base a cualquier fuente de datos. Sin embargo, el almacenamiento en caché puede resultar útil. Al administrarlo, puede hacer que trabajar con su servidor sea más cómodo para el usuario al permitir la carga de ciertas páginas desde el caché, evitando así que se vuelvan a cargar desde su servidor y ahorrando tiempo y tráfico al usuario.

¿Al caché o no?

La capacidad de guardar una página en la caché está determinada por el dinamismo de la información en la fuente de datos. Por lo tanto, usted determina la necesidad de utilizar un caché en función de la vida útil planificada de la página.

Si estamos hablando de formar una muestra a partir de la base de datos (por ejemplo, buscar una palabra ingresada por el usuario), entonces dicha página debe solicitarse al servidor cada vez que llame sin usar un caché, ya que el número de variantes de las palabras solicitadas son enormes, y si también estamos tratando con un conjunto cambiante de datos, entonces el almacenamiento en caché no tiene sentido. O estamos hablando de formar, digamos, un cronograma de visitantes entrantes (que cambia con cada visita, es decir, con casi cada llamada), entonces el almacenamiento en caché es simplemente dañino.

Sin embargo, si estamos hablando del mismo gráfico pero de ayer, entonces se recomienda el almacenamiento en caché, ya que los datos ya no cambiarán y podemos ahorrarnos a nosotros y al usuario recursos y tiempo para cargar dichas páginas colocándolas en un caché local o compartido. . Como continuación de esta situación, la formación de un horario no es en tiempo real, sino cada hora. Aquí puede predecir de antemano la fecha de vencimiento de los datos generados.

Principios generales para almacenar páginas en caché

Un programa PHP puede controlar el almacenamiento en caché de los resultados de su trabajo formando campos adicionales en el encabezado de respuesta HTTP llamando a la función Header().

Varias declaraciones generales típicas no solo de los programas PHP:

• Las páginas enviadas mediante POST nunca se almacenan en caché.
• Las páginas solicitadas mediante GET y que contienen parámetros (hay un "?" en la URL) no se guardan en la caché a menos que se especifique lo contrario.

Por tanto, en la mayoría de situaciones no es necesario añadir instrucciones adicionales al programa. Los principales puntos a los que prestar atención se pueden reducir a dos:

• deshabilitar el almacenamiento en caché de documentos almacenados en caché de forma predeterminada
• Almacenamiento en caché de documentos que no se almacenan en caché de forma predeterminada.

Evitar el almacenamiento en caché de documentos que están almacenados en caché de forma predeterminada

Este problema surge para los scripts PHP que se llaman sin parámetros o son índices de directorios, pero generan datos personalmente para el usuario (por ejemplo, basándose en cookies o agentes de usuario) o funcionan sobre la base de datos que cambian rápidamente. Según la especificación HTTP/1.1, podemos gestionar los siguientes campos:

• Vence- Especifica la fecha de vencimiento del documento. Configurarlo en el pasado determina que el caché está deshabilitado para esta página.
• Control de caché: sin caché- Gestión de caché. El valor sin caché determina si el caché de esta página está deshabilitado. Para la versión del protocolo HTTP/1.0, se aplica "Pragma: no-cache".
• Última modificación- Fecha de la última modificación del contenido. El campo es relevante sólo para páginas estáticas. Apache reemplaza este campo con el valor del campo Fecha para páginas generadas dinámicamente, incluidas las páginas que contienen SSI.

El sitio web www.php.net proporciona el siguiente código para desactivar el almacenamiento en caché.

Encabezado("Expira: lunes 26 de julio de 1997 a las 05:00:00 GMT"); // Fecha del pasado header("Última modificación: " . gmdate("D, d M Y H:i:s") . " GMT"); // encabezado siempre modificado("Cache-Control: no-cache, must-revalidate"); // encabezado HTTP/1.1("Pragma: sin caché"); //HTTP/1.0

Sin embargo, creo que este título es redundante. En la mayoría de los casos es suficiente:

Para marcar un documento como "obsoleto", debe establecer Caducidad igual al campo Fecha.

Header("Expira: " . gmdate("D, d M Y H:i:s") . " GMT");

Bueno, no debemos olvidar que los formularios solicitados mediante POST tampoco están sujetos a almacenamiento en caché.

Almacenamiento en caché de documentos que no se almacenan en caché de forma predeterminada

El problema inverso puede parecer absurdo a primera vista. Sin embargo, esto también es necesario. Además de simplemente minimizar el tráfico, a la hora de desarrollar un programa web se debe tener en cuenta la comodidad del usuario con el mismo. Por ejemplo, algunas páginas de su servidor se crean a partir de datos estáticos de gran volumen. La capacidad de incluirlos en el caché mejorará significativamente la velocidad del servidor para el usuario y lo liberará parcialmente de numerosas generaciones repetidas de dicha página. Encabezado que permite guardar en servidores proxy:

Encabezado("Control de caché: público");

Si una página tiene en cuenta la información almacenada en el navegador del usuario (tipo y versión del navegador, claves, autorización, etc.), dicha página no se puede guardar en un proxy, pero se puede guardar en la memoria caché del navegador local:

Encabezado("Control de caché: privado");

Almacenamiento en caché hasta que caduque la validez

Las soluciones descritas anteriormente son bastante sencillas, aunque adecuadas para la mayoría de los problemas. Pero el protocolo HTTP/1.1 tiene herramientas para una gestión más detallada de la caché de páginas y hay tareas que requieren el uso de estos mecanismos. Como ejemplo, aplicaciones web que trabajan con grandes volúmenes de datos y un dinamismo predecible. La exactitud de los datos puede determinarse tanto por la fecha de la actualización prevista como por los cambios en el contenido. Para estos casos se utilizan diferentes encabezados de control de caché.

Almacenamiento en caché de actualización predictiva

Consideremos un ejemplo: una lista de precios actualizada los lunes. Usted sabe de antemano que el contenido de la página se puede almacenar en caché hasta que comience la nueva semana, lo cual debe indicarse en el encabezado de respuesta para garantizar el comportamiento deseado de la página en el caché.

La tarea principal es conseguir la fecha del próximo lunes en formato RFC-1123.

$dt_tmp=getdate(fecha("U")); header("Expira: " . gmdate("D, d M Y H:i:s", fecha("U")-(86400*($dt_tmp["wday"]-8))) . " GMT"); encabezado("Control de caché: público");

Este método permite controlar eficazmente el comportamiento de una página en la caché y es aplicable a una gran cantidad de páginas; de una forma u otra, es posible seleccionar intervalos de tiempo durante los cuales el contenido de la página permanece constante. La realidad es que las páginas de la mayoría de los sitios dinámicos tienen una vida útil determinada en función de la cual el desarrollador puede crear una experiencia más placentera para el usuario.

Otro enfoque, utilizado cuando la información se actualiza más rápidamente y al mismo tiempo hay mucho tráfico hacia el servidor (de lo contrario, el almacenamiento en caché no será efectivo) es usar el encabezado Cache-control: max-age=segundos, que determina el tiempo después del cual se actualiza la información. El documento se considera obsoleto y tiene mayor prioridad al calcular la "actualidad" del documento.

Si publicas noticias en intervalos de 30 minutos:

Encabezado("Control de caché: público");
encabezado ("Control de caché: edad máxima = 1800");

Almacenamiento en caché de contenido

HTTP/1.1 proporciona una forma de control aún más inteligente basada en el contenido que utiliza directivas Vary. Recomiendo encarecidamente su uso al crear imágenes o textos grandes que, como muestra la práctica, cambian muy raramente. Al mismo tiempo, si el usuario regresa, no se volverá a cargar si el contenido sigue siendo el mismo, y la página se eliminará de su servidor si su contenido ha cambiado.

Consideremos un ejemplo de emisión de una imagen desde una base de datos identificada por ID. La llamada de página se ve así:

Http://www.tu.servidor/viewpic.php3?id=23123

lo que significa que, de acuerdo con las reglas, la página no se guardará en el caché (los parámetros están presentes), pero puedes controlar esto a través del encabezado.

Mysql_connect("host", "usuario", "contraseña"); $image=mysql("db", "seleccione fotografías, escriba las imágenes donde id=$id"); Encabezado("Control de caché: público, debe revalidar"); Encabezado("Variar: ID de contenido"); Encabezado("ID de contenido: ".md5(mysql_result($imagen, 0, "fotos"))); Encabezado("Tipo de contenido: ".mysql_result($imagen, 0, "tipo")); echo mysql_result($imagen, 0, "fotos"); mysql_freeResult($imagen); mysql_close();

La suma MD5 del contenido de la imagen se utiliza para el control. Mientras el contenido no haya cambiado, la cantidad permanecerá constante. Si el contenido de la base de datos del servidor cambia, el cliente emitirá una solicitud para regenerar el contenido. Mientras la imagen esté constantemente el contenido se mostrará desde el caché.

Notas para el Apache ruso

Y un mensaje agradable (o desagradable) para los usuarios rusos de Apache. Dado que el servidor genera datos antiguos utilizando una codificación personalizada, automáticamente proporciona a TODAS las páginas (no solo las dinámicas) encabezados de prohibición de almacenamiento en caché.