Comment réduire la sortie html d'une page php?

Je recherche un script ou une classe php qui peut réduire la sortie html de ma page php comme le fait la vitesse de la page Google.

Comment puis-je faire ceci?

CSS et Javascript

Considérez le lien suivant pour minifier les fichiers Javascript / CSS: https://github.com/mrclay/minify

HTML

Dites à Apache de fournir du HTML avec GZip - cela réduit généralement la taille de la réponse d'environ 70%. (Si vous utilisez Apache, le module de configuration de gzip dépend de votre version: Apache 1.3 utilise mod_gzip tandis qu'Apache 2.x utilise mod_deflate.)

Accept-Encoding: gzip, dégonfler

Encodage de contenu: gzip

Utilisez l' extrait de code suivant pour supprimer les espaces blancs du HTML avec le tampon de l'aide 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");

?>

Activez gzip si vous souhaitez le faire correctement. Vous pouvez également faire quelque chose comme ceci:

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

Cela supprime environ 30% de la taille de la page en transformant votre html en une seule ligne, sans onglets, sans nouvelles lignes, sans commentaires. Le kilométrage peut varier

Toutes les preg_replace()solutions ci-dessus ont des problèmes de commentaires sur une seule ligne, de commentaires conditionnels et d'autres pièges. Je recommanderais de profiter du projet Minify bien testé plutôt que de créer votre propre regex à partir de zéro.

Dans mon cas, je place le code suivant en haut d'une page PHP pour la réduire:

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

J'ai essayé plusieurs minificateurs et ils en retirent trop ou trop peu.

Ce code supprime les espaces vides redondants et les balises HTML facultatives (fin). De plus, il joue en toute sécurité et ne supprime rien qui pourrait potentiellement casser HTML, JS ou CSS.

Le code montre également comment faire cela dans 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);
  }
}

Mais notez que lorsque vous utilisez la compression gZip, votre code est beaucoup plus compressé que toute minification peut le faire, combiner la minification et gZip est inutile, car le temps gagné par le téléchargement est perdu par la minification et économise également un minimum.

Voici mes résultats (téléchargement via le réseau 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

Ce travail pour moi.

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

Créez un fichier PHP en dehors de la racine de votre document. Si la racine de votre document est

/var/www/html/

créer un fichier nommé minify.php un niveau au-dessus

/var/www/minify.php

Copiez et collez le code PHP suivant dedans

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

Enregistrez le fichier minify.php et ouvrez le fichier php.ini. S'il s'agit d'un serveur dédié / VPS, recherchez l'option suivante, sur l'hébergement partagé avec php.ini personnalisé, ajoutez-la.

auto_prepend_file = /var/www/minify.php

Référence: http://websistent.com/how-to-use-php-to-minify-html-output/

vous pouvez consulter cet ensemble de classes: https://code.google.com/p/minify/source/browse/?name=master#git%2Fmin%2Flib%2FMinify , vous trouverez la minification html / css / js cours là-bas.

vous pouvez également essayer ceci: http://code.google.com/p/htmlcompressor/

Bonne chance :)

Vous pouvez consulter HTML TIDY - http://uk.php.net/tidy

Il peut être installé en tant que module PHP et supprimera (correctement, en toute sécurité) les espaces blancs et toute autre méchanceté, tout en produisant un balisage HTML / XHTML parfaitement valide. Cela nettoiera également votre code, ce qui peut être une bonne chose ou une chose terrible, selon votre capacité à écrire du code valide en premier lieu ;-)

De plus, vous pouvez gzip la sortie en utilisant le code suivant au début de votre fichier:

ob_start('ob_gzhandler');

Tout d'abord, gzip peut vous aider plus qu'un Minifier Html

1. Avec 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. Avec apache, vous pouvez utiliser mod_gzip

Deuxièmement: avec gzip + Html Minification, vous pouvez réduire considérablement la taille du fichier !!!

J'ai créé ce HtmlMinifier pour PHP .

Vous pouvez le récupérer par le compositeur: composer require arjanschouten/htmlminifier dev-master.

Il existe un fournisseur de services Laravel. Si vous n'utilisez pas Laravel, vous pouvez l'utiliser depuis 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();

Comme vous pouvez le voir, vous pouvez étendre beaucoup de choses ici et vous pouvez passer diverses options. Vérifiez le readme pour voir toutes les options disponibles.

Ce HtmlMinifier est complet et sûr. Il faut 3 étapes pour le processus de minification:

1. Remplacez temporairement le contenu critique par un espace réservé.
2. Exécutez les stratégies de minification.
3. Restaurez le contenu d'origine.

Je vous suggère de mettre en cache la sortie de vos vues. Le processus de minification doit être un processus unique. Ou faites-le par exemple basé sur un intervalle.

Des repères clairs ne sont pas créés à l'époque. Cependant, le minificateur peut réduire la taille de la page de 5 à 25% en fonction de votre balisage!

Si vous souhaitez ajouter vos propres stratégies, vous pouvez utiliser addPlaceholderles addMinifierméthodes et.

J'ai un gist GitHub contenant des fonctions PHP pour minifier les fichiers HTML, CSS et JS → https://gist.github.com/taufik-nurrohman/d7b310dea3b33e4732c0

Voici comment réduire la sortie HTML à la volée avec le tampon de sortie:

<?php

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

ob_start('minify_html');

?>

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

<?php echo ob_get_clean(); ?>

Si vous souhaitez supprimer toutes les nouvelles lignes de la page, utilisez ce code rapide:

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

Merci à Andrew . Voici ce que vous avez fait pour l'utiliser dans cakePHP:

1. Télécharger minify-2.1.7
2. Décompressez le fichier et copiez le sous-dossier min dans le dossier Vendor de cake

3. Crée MinifyCodeHelper.php dans le View / Helper de cake comme ceci:

   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. Activé mon Helper dans AppController

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

5 ... Voila!

Ma conclusion: si les modules de dégonflage et d'en-tête d'Apache sont désactivés dans votre serveur, votre gain est de 21% de taille en moins et de 0,35 s plus en demande de compression (ce nombre était dans mon cas).

Mais si vous aviez activé les modules d'Apache, la réponse compressée n'a pas de différence significative (1,3% pour moi) et le temps de compression est le même (0,3 s pour moi).

Alors ... pourquoi ai-je fait ça? 'couse la doc de mon projet est tout dans les commentaires (php, css et js) et mon utilisateur final n'a pas besoin de voir ça;)

Vous pouvez utiliser un minificateur Java bien testé comme HTMLCompressor en l' appelant à l' aide de passthru( exec).
N'oubliez pas de rediriger la console en utilisant2>&1

Cela peut cependant ne pas être utile si la vitesse est un problème. Je l'utilise pour la sortie php statique