web-dev-qa-db-fra.com

Comment réduire les sorties HTML de pages php?

Je suis à la recherche d'un script ou d'une classe php qui puisse minimiser la sortie html de ma page php, comme le fait google page speed.

Comment puis-je faire ceci?

phphtmlminify
131
m3tsys

CSS et Javascript

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

HTML

Indiquez à Apache de fournir du code 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 alors qu'Apache 2.x utilise mod_deflate.)

Accept-Encoding: gzip, deflate

Content-Encoding: gzip

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

?>
195
Rakesh Sankar

Activez gzip si vous voulez le faire correctement. Vous pouvez aussi faire quelque chose comme ça:

$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 code HTML en une seule ligne, sans onglets, sans nouvelles lignes, sans commentaires. Le kilométrage peut varier

26
dogmatic69

Toutes les solutions preg_replace() ci-dessus présentent des problèmes de commentaires sur une seule ligne, de commentaires conditionnels et d'autres pièges. Je vous recommande de tirer parti du bien testé projet Minify 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 le 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');
17
Andrew

J'ai essayé plusieurs minifiers et ils enlèvent trop ou trop peu.

Ce code supprime les espaces vides redondants et les balises HTML (de fin) facultatives. En outre, il joue la sécurité et ne supprime rien qui pourrait potentiellement casser HTML, JS ou CSS.

De plus, le code montre 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 n’importe quelle minification. Combiner minification et gZip est donc inutile, car le gain de temps généré par le téléchargement est perdu par la minification et permet également d’économiser 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
16
Radek Pech

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;
}
5
Mohamad Hamouday

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

/var/www/html/

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

/var/www/minify.php

Copier coller le code PHP suivant dans celui-ci

<?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, ajoutez-la à l'hébergement partagé avec php.ini personnalisé.

auto_prepend_file = /var/www/minify.php

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

4
Avi Tyagi

vous pouvez consulter cet ensemble de classes: https://code.google.com/p/minify/source/browse/?name=master#git%2Fmin%2Flib%2FMinify , vous y trouver des classes de minification html/css/js.

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

Bonne chance :)

3
Mtz

J'ai un GitHub Gist contient PHP fonctions pour minifier les fichiers HTML, CSS et JS → https: // Gist .github.com/tovic/d7b310dea3b33e4732c

Voici comment minimiser 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(); ?>
2
Taufik Nurrohman

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éé ceci HtmlMinifier for PHP .

Vous pouvez le récupérer via le composeur: 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 prolonger 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 le contenu critique temporaire par un espace réservé.
  2. Exécutez les stratégies de minification.
  3. Restaurer le contenu d'origine.

Je suggérerais que vous mettiez en cache la sortie de vos vues. Le processus de minification devrait être un processus unique. Ou faites-le par exemple en fonction d'intervalle.

Des repères clairs ne sont pas créés à ce moment. Toutefois, le minificateur peut réduire la taille de la page de 5 à 25% en fonction de votre marquage!

Si vous souhaitez ajouter vos propres stratégies, vous pouvez utiliser les méthodes addPlaceholder et addMinifier .

2
ArjanSchouten

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

Il peut être installé en tant que module PHP et permettra (correctement, en toute sécurité) de supprimer les espaces, ainsi que toute autre nuisance, tout en affichant un balisage HTML/XHTML parfaitement valide. Cela nettoiera également votre code, ce qui peut être une bonne chose ou une chose terrible, en fonction de votre capacité à écrire du code valide ;-)

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

ob_start('ob_gzhandler');
2
Rudi Visser

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;}
});
1
زياد

Vous pouvez utiliser un minifier Java bien testé, comme HTMLCompressor en l'invoquant avec passthru (exec).
N'oubliez pas de rediriger la console à l'aide de 2>&1

Cela peut toutefois ne pas être utile si la vitesse est une préoccupation. Je l'utilise pour une sortie php statique

0
Ujjwal Singh

Merci à Andrew . Voici ce que vous avez fait pour utiliser ceci dans CakePHP:

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

  3. Crée MinifyCodeHelper.php dans la vue/aide de gâteau 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 assistant dans AppController

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

5 ... voila!

Ma conclusion: si les modules de déflation et d’en-têtes d’Apache sont désactivés sur votre serveur, votre gain est 21% inférieur en taille et 0,35 seconde en plus de la demande de compression (ces chiffres étaient dans mon cas).

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

Alors ... pourquoi j'ai fait ça? 'Couse la doc de mon projet est tout en commentaires (php, css et js) et mon utilisateur final n'a pas besoin de voir cela;)

0
bocapio