remove - Cómo minificar la salida html de la página php?

remove html tags php

Question

Estoy buscando una secuencia de comandos php o clase que pueda minificar mi salida html de página php, como lo hace google page speed.

¿Cómo puedo hacer esto?

Answer 1

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

/var/www/html/

crea un archivo llamado minify.php un nivel arriba

/var/www/minify.php

Copia y pega 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 una búsqueda de servidores / VPS dedicados para la siguiente opción, en el 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/

Answer 2

CSS y Javascript

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

HTML

Indique 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-Codificar: gzip, desinflar

Content-Encoding: gzip

Utilice el siguiente fragmento para eliminar espacios en blanco del HTML con la ayuda del buffer de 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");
?>

Answer 3

Active gzip si quiere 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 kilometraje puede variar

Answer 4

Este trabajo para mí.

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;
}

Answer 5

Gracias a Esto es lo que hizo para usar esto en CakePHP:

1. Descargar minify-2.1.7
2. Desempaquete el archivo y copie la subcarpeta mínima en la carpeta Vendor del vendedor.

3. Crea MinifyCodeHelper.php en View / Helper de la torta así:

   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 encabezados de Apache están deshabilitados en su servidor, su ganancia es 21% menos de tamaño y 0.35s más en la solicitud de compresión (estos números fueron en mi caso).

Pero si tienes habilitados 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;)

Answer 6

Probé varios minificadores y eliminan muy poco o demasiado.

Este código elimina los espacios vacíos redundantes y las etiquetas HTML (finales) opcionales. También se juega de forma segura y no elimina nada que podría 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 al usar la compresión gZip su código se comprime mucho más que cualquier minificación, por lo que no es necesario combinar la minificación y gZip, ya que 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

Answer 7

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

Se puede instalar como un módulo de PHP y eliminará (de forma correcta y segura) el espacio en blanco y todas las demás maldades, al mismo tiempo que se genera un marcado de HTML / XHTML perfectamente válido. También limpiará su código, lo que puede ser algo grandioso o algo terrible, dependiendo de cuán bueno sea usted para escribir un código válido en primer lugar ;-)

Además, puede gzip la salida utilizando el siguiente código al inicio de su archivo:

ob_start(''ob_gzhandler'');

Answer 8

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

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

Buena suerte :)

Answer 9

Puede utilizar un HTMLCompressor Java bien probado como HTMLCompressor invocando mediante passthru ( exec ).
Recuerde redirigir la consola usando 2>&1

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

Answer 10

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;}
});

Answer 11

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

Aquí se explica cómo minimizar el resultado HTML sobre la marcha con el buffer 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(); ?>

Answer 12

Todas las soluciones preg_replace() anteriores tienen problemas de comentarios de una sola línea, comentarios condicionales y otras trampas. Recomiendo aprovechar el bien probado proyecto Minify en lugar de crear tu 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'');

Answer 13

Antes que nada, 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 la Minimación gzip + Html puedes reducir el tamaño del archivo drásticamente!

Creé este HtmlMinifier para PHP .

Puede recuperarlo a través del compositor: el 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 ampliar muchas cosas aquí y puede pasar varias opciones. Verifique 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 el contenido crítico temporal por un marcador de posición.
2. Ejecuta las estrategias de minificación.
3. Restaure el contenido original.

Sugeriría que guardes en caché el resultado de tus puntos de vista. El proceso de minificación debe ser un proceso de una sola vez. O hazlo, por ejemplo, basado en intervalos.

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

Si desea agregar sus propias estrategias, puede usar addPlaceholder y los métodos addMinifier .