¿Cómo minimizar la salida html de la página php?

Estoy buscando un script php o una clase que pueda minimizar la salida html de mi página php como lo hace la velocidad de la página de google.

¿Cómo puedo hacer esto?

CSS y Javascript

Considere el siguiente enlace para minificar archivos Javascript / CSS: https://github.com/mrclay/minify

HTML

Dígale a Apache que entregue HTML con GZip; esto generalmente reduce el tamaño de la respuesta en aproximadamente un 70%. (Si usa Apache, el módulo que configura gzip depende de su versión: Apache 1.3 usa mod_gzip mientras que Apache 2.x usa mod_deflate).

Aceptar-codificación: gzip, desinflar

Codificación de contenido: gzip

Use el siguiente fragmento para eliminar espacios en blanco del HTML con el búfer de ayuda ob_start:

<?php

function sanitize_output($buffer) {

    $search = array(
        '/\>[^\S ]+/s',     // strip whitespaces after tags, except space
        '/[^\S ]+\</s',     // strip whitespaces before tags, except space
        '/(\s)+/s',         // shorten multiple whitespace sequences
        '/<!--(.|\s)*?-->/' // Remove HTML comments
    );

    $replace = array(
        '>',
        '<',
        '\\1',
        ''
    );

    $buffer = preg_replace($search, $replace, $buffer);

    return $buffer;
}

ob_start("sanitize_output");

?>

Active gzip si desea hacerlo correctamente. También puedes hacer algo como esto:

$this->output = preg_replace(
    array(
        '/ {2,}/',
        '/<!--.*?-->|\t|(?:\r?\n[ \t]*)+/s'
    ),
    array(
        ' ',
        ''
    ),
    $this->output
);

Esto elimina aproximadamente el 30% del tamaño de la página al convertir su html en una línea, sin pestañas, sin líneas nuevas, sin comentarios. El millaje puede variar

Todas las preg_replace()soluciones anteriores tienen problemas de comentarios de una sola línea, comentarios condicionales y otras dificultades. Recomiendo aprovechar el bien probado proyecto Minify en lugar de crear su propia expresión regular desde cero.

En mi caso, coloco el siguiente código en la parte superior de una página PHP para minimizarlo:

function sanitize_output($buffer) {
    require_once('min/lib/Minify/HTML.php');
    require_once('min/lib/Minify/CSS.php');
    require_once('min/lib/JSMin.php');
    $buffer = Minify_HTML::minify($buffer, array(
        'cssMinifier' => array('Minify_CSS', 'minify'),
        'jsMinifier' => array('JSMin', 'minify')
    ));
    return $buffer;
}
ob_start('sanitize_output');

He probado varios minificadores y eliminan muy poco o demasiado.

Este código elimina espacios vacíos redundantes y etiquetas HTML (finales) opcionales. También es seguro y no elimina nada que pueda romper HTML, JS o CSS.

Además, el código muestra cómo hacerlo en Zend Framework:

class Application_Plugin_Minify extends Zend_Controller_Plugin_Abstract {

  public function dispatchLoopShutdown() {
    $response = $this->getResponse();
    $body = $response->getBody(); //actually returns both HEAD and BODY

    //remove redundant (white-space) characters
    $replace = array(
        //remove tabs before and after HTML tags
        '/\>[^\S ]+/s'   => '>',
        '/[^\S ]+\</s'   => '<',
        //shorten multiple whitespace sequences; keep new-line characters because they matter in JS!!!
        '/([\t ])+/s'  => ' ',
        //remove leading and trailing spaces
        '/^([\t ])+/m' => '',
        '/([\t ])+$/m' => '',
        // remove JS line comments (simple only); do NOT remove lines containing URL (e.g. 'src="http://server.com/"')!!!
        '~//[a-zA-Z0-9 ]+$~m' => '',
        //remove empty lines (sequence of line-end and white-space characters)
        '/[\r\n]+([\t ]?[\r\n]+)+/s'  => "\n",
        //remove empty lines (between HTML tags); cannot remove just any line-end characters because in inline JS they can matter!
        '/\>[\r\n\t ]+\</s'    => '><',
        //remove "empty" lines containing only JS's block end character; join with next line (e.g. "}\n}\n</script>" --> "}}</script>"
        '/}[\r\n\t ]+/s'  => '}',
        '/}[\r\n\t ]+,[\r\n\t ]+/s'  => '},',
        //remove new-line after JS's function or condition start; join with next line
        '/\)[\r\n\t ]?{[\r\n\t ]+/s'  => '){',
        '/,[\r\n\t ]?{[\r\n\t ]+/s'  => ',{',
        //remove new-line after JS's line end (only most obvious and safe cases)
        '/\),[\r\n\t ]+/s'  => '),',
        //remove quotes from HTML attributes that does not contain spaces; keep quotes around URLs!
        '~([\r\n\t ])?([a-zA-Z0-9]+)="([a-zA-Z0-9_/\\-]+)"([\r\n\t ])?~s' => '$1$2=$3$4', //$1 and $4 insert first white-space character found before/after attribute
    );
    $body = preg_replace(array_keys($replace), array_values($replace), $body);

    //remove optional ending tags (see http://www.w3.org/TR/html5/syntax.html#syntax-tag-omission )
    $remove = array(
        '</option>', '</li>', '</dt>', '</dd>', '</tr>', '</th>', '</td>'
    );
    $body = str_ireplace($remove, '', $body);

    $response->setBody($body);
  }
}

Pero tenga en cuenta que cuando usa la compresión gZip, su código se comprime mucho más de lo que cualquier minificación puede hacerlo, ya que combinar minificación y gZip no tiene sentido, porque el tiempo ahorrado por la descarga se pierde por la minificación y también ahorra un mínimo.

Aquí están mis resultados (descargar a través de la red 3G):

 Original HTML:        150kB       180ms download
 gZipped HTML:          24kB        40ms
 minified HTML:        120kB       150ms download + 150ms minification
 min+gzip HTML:         22kB        30ms download + 150ms minification

Este trabajo para mi.

function Minify_Html($Html)
{
   $Search = array(
    '/(\n|^)(\x20+|\t)/',
    '/(\n|^)\/\/(.*?)(\n|$)/',
    '/\n/',
    '/\<\!--.*?-->/',
    '/(\x20+|\t)/', # Delete multispace (Without \n)
    '/\>\s+\</', # strip whitespaces between tags
    '/(\"|\')\s+\>/', # strip whitespaces between quotation ("') and end tags
    '/=\s+(\"|\')/'); # strip whitespaces between = "'

   $Replace = array(
    "\n",
    "\n",
    " ",
    "",
    " ",
    "><",
    "$1>",
    "=$1");

$Html = preg_replace($Search,$Replace,$Html);
return $Html;
}

Cree un archivo PHP fuera de la raíz de su documento. Si la raíz de tu documento es

/var/www/html/

cree un archivo llamado minify.php un nivel por encima de él

/var/www/minify.php

Copie y pegue el siguiente código PHP en él

<?php
function minify_output($buffer){
    $search = array('/\>[^\S ]+/s','/[^\S ]+\</s','/(\s)+/s');
    $replace = array('>','<','\\1');
    if (preg_match("/\<html/i",$buffer) == 1 && preg_match("/\<\/html\>/i",$buffer) == 1) {
        $buffer = preg_replace($search, $replace, $buffer);
    }
    return $buffer;
}
ob_start("minify_output");?>

Guarde el archivo minify.php y abra el archivo php.ini. Si se trata de un servidor dedicado / VPS, busque la siguiente opción, en un alojamiento compartido con php.ini personalizado, agréguelo.

auto_prepend_file = /var/www/minify.php

Referencia: http://websistent.com/how-to-use-php-to-minify-html-output/

puedes consultar este conjunto de clases: https://code.google.com/p/minify/source/browse/?name=master#git%2Fmin%2Flib%2FMinify , encontrarás minificación html / css / js clases allí.

También puedes probar esto: http://code.google.com/p/htmlcompressor/

Buena suerte :)

Puede consultar HTML TIDY - http://uk.php.net/tidy

Se puede instalar como un módulo PHP y eliminará (correctamente, de forma segura) los espacios en blanco y cualquier otra molestia, al tiempo que genera un marcado HTML / XHTML perfectamente válido. También limpiará su código, lo que puede ser algo grandioso o terrible, dependiendo de lo bueno que sea para escribir un código válido en primer lugar ;-)

Además, puede comprimir la salida usando el siguiente código al comienzo de su archivo:

ob_start('ob_gzhandler');

En primer lugar, gzip puede ayudarte más que un Minificador Html

1. Con nginx :

   gzip on;
   gzip_disable "msie6";
   
   gzip_vary on;
   gzip_proxied any;
   gzip_comp_level 6;
   gzip_buffers 16 8k;
   gzip_http_version 1.1;
   gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

2. Con apache puedes usar mod_gzip

Segundo: ¡con gzip + Html Minification puede reducir drásticamente el tamaño del archivo!

He creado este HtmlMinifier para PHP .

Se puede recuperar a través compositor: composer require arjanschouten/htmlminifier dev-master.

Hay un proveedor de servicios Laravel. Si no está usando Laravel, puede usarlo desde PHP.

// create a minify context which will be used through the minification process
$context = new MinifyContext(new PlaceholderContainer());
// save the html contents in the context
$context->setContents('<html>My html...</html>');
$minify = new Minify();
// start the process and give the context with it as parameter
$context = $minify->run($context);

// $context now contains the minified version
$minifiedContents = $context->getContents();

Como puede ver, puede extender muchas cosas aquí y puede pasar varias opciones. Consulte el archivo Léame para ver todas las opciones disponibles.

Este HtmlMinifier es completo y seguro. Se requieren 3 pasos para el proceso de minificación:

1. Reemplace contenido crítico temporal con un marcador de posición.
2. Ejecute las estrategias de minificación.
3. Restaurar el contenido original.

Te sugiero que guardes en caché la salida de tus vistas. El proceso de minificación debe ser un proceso de una sola vez. O hágalo por ejemplo basado en intervalos.

Los puntos de referencia claros no se crean en el momento. Sin embargo, el minificador puede reducir el tamaño de la página en un 5-25% según el marcado.

Si desea agregar sus propias estrategias, puede usar addPlaceholderlos addMinifiermétodos y.

Tengo una esencia de GitHub que contiene funciones PHP para minificar archivos HTML, CSS y JS → https://gist.github.com/taufik-nurrohman/d7b310dea3b33e4732c0

Aquí se explica cómo minimizar la salida HTML sobre la marcha con el búfer de salida:

<?php

include 'path/to/php-html-css-js-minifier.php';

ob_start('minify_html');

?>

<!-- HTML code goes here ... -->

<?php echo ob_get_clean(); ?>

Si desea eliminar todas las líneas nuevas en la página, use este código rápido:

ob_start(function($b){
if(strpos($b, "<html")!==false) {
return str_replace(PHP_EOL,"",$b);
} else {return $b;}
});

Gracias a Andrew . Esto es lo que hizo para usar esto en cakePHP:

1. Descargar minify-2.1.7
2. Descomprima el archivo y copie la subcarpeta min en la carpeta Vendor de cake

3. Crea MinifyCodeHelper.php en View / Helper de cake de esta manera:

   App::import('Vendor/min/lib/Minify/', 'HTML');
   App::import('Vendor/min/lib/Minify/', 'CommentPreserver');
   App::import('Vendor/min/lib/Minify/CSS/', 'Compressor');
   App::import('Vendor/min/lib/Minify/', 'CSS');
   App::import('Vendor/min/lib/', 'JSMin');
   class MinifyCodeHelper extends Helper {
       public function afterRenderFile($file, $data) {
           if( Configure::read('debug') < 1 ) //works only e production mode
               $data = Minify_HTML::minify($data, array(
                   'cssMinifier' => array('Minify_CSS', 'minify'),
                   'jsMinifier' => array('JSMin', 'minify')
               ));
           return $data;
       }
   }

4. Habilitado mi ayudante en AppController

   public $ helpers = array ('Html', '...', 'MinifyCode');

5 ... ¡Voila!

Mi conclusión: si los módulos de deflación y encabezado de apache están deshabilitados en su servidor, su ganancia es un 21% menor en tamaño y 0.35s más en la solicitud de compresión (estos números fueron en mi caso).

Pero si hubiera habilitado los módulos de apache, la respuesta comprimida no tiene una diferencia significativa (1.3% para mí) y el tiempo para comprimir es el samne (0.3s para mí).

Entonces ... ¿por qué hice eso? porque el documento de mi proyecto está todo en comentarios (php, css y js) y mi usuario final no necesita ver esto;)

Puede usar un minificador Java bien probado como HTMLCompressor invocandolo usando passthru( exec).
Recuerde redirigir la consola usando2>&1

Sin embargo, esto puede no ser útil si la velocidad es una preocupación. Lo uso para la salida estática de php