Come minimizzare l'output html della pagina php?

Sto cercando uno script o una classe php in grado di minimizzare l'output html della mia pagina php come fa la velocità della pagina di Google.

Come posso fare questo?

CSS e Javascript

Considera il seguente link per minimizzare i file Javascript / CSS: https://github.com/mrclay/minify

HTML

Di 'ad Apache di fornire HTML con GZip - questo generalmente riduce le dimensioni della risposta di circa il 70%. (Se usi Apache, il modulo che configura gzip dipende dalla tua versione: Apache 1.3 usa mod_gzip mentre Apache 2.x usa mod_deflate.)

Accetta-codifica: gzip, deflate

Codifica del contenuto: gzip

Utilizzare il frammento seguente per rimuovere gli spazi bianchi dall'HTML con il buffer della guida di 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");

?>

Attiva gzip se vuoi farlo correttamente. Puoi anche fare qualcosa del genere:

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

Questo rimuove circa il 30% delle dimensioni della pagina trasformando il tuo html in una riga, nessuna scheda, nessuna nuova riga, nessun commento. Il chilometraggio può variare

Tutte le preg_replace()soluzioni sopra hanno problemi di commenti a riga singola, commenti condizionali e altre insidie. Consiglierei di approfittare del collaudato progetto Minify piuttosto che creare il tuo regex da zero.

Nel mio caso inserisco il seguente codice nella parte superiore di una pagina PHP per minimizzarlo:

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

Ho provato diversi minificatori e rimuovono troppo poco o troppo.

Questo codice rimuove gli spazi vuoti ridondanti e i tag HTML (finali) opzionali. Inoltre lo gioca in modo sicuro e non rimuove nulla che potrebbe potenzialmente rompere HTML, JS o CSS.

Anche il codice mostra come farlo in 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);
  }
}

Tuttavia, quando si utilizza la compressione gZip, il codice viene compresso molto più di qualsiasi minificazione, pertanto la combinazione di minificazione e gZip è inutile, poiché il tempo risparmiato dal download viene perso dalla minificazione e consente di risparmiare anche il minimo.

Ecco i miei risultati (download tramite rete 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

Questo lavoro per me.

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

Crea un file PHP al di fuori della radice del documento. Se la radice del documento è

/var/www/html/

crea un file chiamato minify.php a un livello sopra di esso

/var/www/minify.php

Copia incolla il seguente codice PHP in esso

<?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");?>

Salvare il file minify.php e aprire il file php.ini. Se si tratta di una ricerca server / VPS dedicata per la seguente opzione, su hosting condiviso con php.ini personalizzato aggiungerlo.

auto_prepend_file = /var/www/minify.php

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

puoi dare un'occhiata a questo gruppo di classi: https://code.google.com/p/minify/source/browse/?name=master#git%2Fmin%2Flib%2FMinify , troverai minificazione html / css / js lezioni lì.

puoi anche provare questo: http://code.google.com/p/htmlcompressor/

In bocca al lupo :)

Puoi guardare in HTML TIDY - http://uk.php.net/tidy

Può essere installato come modulo PHP e rimuoverà (correttamente, in modo sicuro) gli spazi bianchi e tutte le altre cattiverie, pur generando un markup HTML / XHTML perfettamente valido. Pulirà anche il tuo codice, che può essere una cosa grandiosa o terribile, a seconda di quanto sei bravo a scrivere codice valido in primo luogo ;-)

Inoltre, è possibile decomprimere l'output utilizzando il seguente codice all'inizio del file:

ob_start('ob_gzhandler');

Prima di tutto, gzip può aiutarti più di un minimizer 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 puoi usare mod_gzip

Secondo: con gzip + Html Minification puoi ridurre drasticamente le dimensioni del file !!!

Ho creato questo HtmlMinifier per PHP .

È possibile recuperare attraverso compositore: composer require arjanschouten/htmlminifier dev-master.

C'è un fornitore di servizi Laravel. Se non stai usando Laravel, puoi usarlo da 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();

Come puoi vedere puoi estendere un sacco di cose qui e puoi passare varie opzioni. Controlla il file Leggimi per vedere tutte le opzioni disponibili.

Questo HtmlMinifier è completo e sicuro. Sono necessari 3 passaggi per il processo di minificazione:

1. Sostituisci temporaneamente i contenuti critici con un segnaposto.
2. Esegui le strategie di minificazione.
3. Ripristina il contenuto originale.

Suggerirei di memorizzare nella cache l'output delle visualizzazioni. Il processo di minificazione dovrebbe essere una volta. Oppure fallo ad esempio in base all'intervallo.

I benchmark chiari non sono stati creati al momento. Tuttavia, il minificatore può ridurre le dimensioni della pagina del 5-25% in base al markup!

Se vuoi aggiungere le tue strategie, puoi usare addPlaceholderi addMinifiermetodi e.

Ho una sintesi di GitHub contiene funzioni PHP per minimizzare i file HTML, CSS e JS → https://gist.github.com/taufik-nurrohman/d7b310dea3b33e4732c0

Ecco come minimizzare l'output HTML al volo con il buffer di output:

<?php

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

ob_start('minify_html');

?>

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

<?php echo ob_get_clean(); ?>

Se si desidera rimuovere tutte le nuove righe nella pagina, utilizzare questo codice rapido:

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

Grazie a Andrew . Ecco cosa ha fatto per usarlo in cakePHP:

1. Scarica minify-2.1.7
2. Decomprimere il file e copiare la sottocartella minima nella cartella Venditore della torta

3. Crea MinifyCodeHelper.php in View / Helper di cake in questo modo:

   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. Abilitato il mio aiuto in AppController

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

5 ... Voila!

La mia conclusione: se i moduli deflate e headers di apache sono disabilitati nel tuo server, il tuo guadagno è del 21% in meno di dimensioni e 0,35s più nella richiesta di compressione (questo numero era nel mio caso).

Ma se avessi abilitato i moduli di apache la risposta compressa non avrebbe differenze significative (1,3% per me) e il tempo di compressione è il samne (0,3 secondi per me).

Quindi ... perché l'ho fatto? 'uso del documento del mio progetto è tutto nei commenti (php, css e js) e il mio utente finale non ha bisogno di vedere questo;)

È possibile utilizzare un minificatore Java ben collaudato come HTMLCompressor invocandolo con passthru( exec).
Ricorda di reindirizzare la console utilizzando2>&1

Questo tuttavia potrebbe non essere utile, se la velocità è un problema. Lo uso per output php statico