Jak zminimalizować wynik html strony php?

Szukam skryptu lub klasy php, która może zminimalizować dane wyjściowe html strony php, tak jak robi to prędkość strony Google.

W jaki sposób mogę to zrobić?

CSS i Javascript

Rozważ następujący link, aby zminimalizować pliki Javascript / CSS: https://github.com/mrclay/minify

HTML

Powiedz Apache, aby dostarczał HTML za pomocą GZip - zwykle zmniejsza to rozmiar odpowiedzi o około 70%. (Jeśli używasz Apache, moduł konfigurujący gzip zależy od twojej wersji: Apache 1.3 używa mod_gzip, podczas gdy Apache 2.x używa mod_deflate.)

Zaakceptuj-kodowanie: gzip, deflate

Kodowanie zawartości: gzip

Użyj poniższego fragmentu kodu, aby usunąć spacje z kodu HTML za pomocą bufora pomocy 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");

?>

Włącz gzip, jeśli chcesz zrobić to poprawnie. Możesz też po prostu zrobić coś takiego:

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

To usuwa około 30% rozmiaru strony, zamieniając HTML w jedną linię, bez zakładek, bez nowych linii, bez komentarzy. Przebieg może się różnić

Wszystkie preg_replace()powyższe rozwiązania mają problemy z komentarzami jednowierszowymi, komentarzami warunkowymi i innymi pułapkami. Polecam skorzystać z dobrze przetestowanego projektu Minify zamiast tworzenia własnego wyrażenia regularnego od podstaw.

W moim przypadku umieszczam następujący kod na górze strony PHP, aby ją zminimalizować:

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

Wypróbowałem kilka minifier i albo usuwają za mało, albo za dużo.

Ten kod usuwa zbędne puste spacje i opcjonalne znaczniki HTML (końcowe). Odgrywa również bezpiecznie i nie usuwa niczego, co mogłoby potencjalnie zepsuć HTML, JS lub CSS.

Kod pokazuje również, jak to zrobić w 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);
  }
}

Ale pamiętaj, że podczas korzystania z kompresji gZip twój kod jest kompresowany znacznie bardziej niż każda minifikacja może to zrobić, łącząc minifikację i gZip, jest bezcelowe, ponieważ czas zaoszczędzony podczas pobierania jest tracony przez minifikację, a także oszczędza minimum.

Oto moje wyniki (pobieranie przez sieć 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

Ta praca dla mnie.

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

Utwórz plik PHP poza katalogiem głównym. Jeśli twój dokument główny to

/var/www/html/

utwórz plik o nazwie minify.php jeden poziom wyżej

/var/www/minify.php

Skopiuj, wklej do niego następujący kod PHP

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

Zapisz plik minify.php i otwórz plik php.ini. Jeśli jest to serwer dedykowany / VPS, wyszukaj następującą opcję, na współdzielonym hostingu z niestandardowym php.ini dodaj ją.

auto_prepend_file = /var/www/minify.php

Źródła: http://websistent.com/how-to-use-php-to-minify-html-output/

możesz sprawdzić ten zestaw klas: https://code.google.com/p/minify/source/browse/?name=master#git%2Fmin%2Flib%2FMinify , znajdziesz minifikację html / css / js zajęcia tam.

możesz także spróbować tego: http://code.google.com/p/htmlcompressor/

Powodzenia :)

Możesz zajrzeć do HTML TIDY - http://uk.php.net/tidy

Może być zainstalowany jako moduł PHP i usunie (poprawnie, bezpiecznie) białe znaki i wszystkie inne nieprzyjemności, jednocześnie wysyłając doskonale poprawne znaczniki HTML / XHTML. Oczyści również twój kod, co może być świetną lub straszną rzeczą, w zależności od tego, jak dobry jesteś w pisaniu prawidłowego kodu ;-)

Ponadto możesz spakować dane wyjściowe za pomocą następującego kodu na początku pliku:

ob_start('ob_gzhandler');

Przede wszystkim gzip może Ci pomóc więcej niż Html Minifier

1. Z 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. W Apache możesz użyć mod_gzip

Po drugie: dzięki gzip + Html Minification możesz drastycznie zmniejszyć rozmiar pliku !!!

Stworzyłem ten HtmlMinifier dla PHP .

Można pobrać go przez kompozytora: composer require arjanschouten/htmlminifier dev-master.

Istnieje dostawca usług Laravel. Jeśli nie używasz Laravela, możesz go używać z poziomu 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();

Jak widać, możesz tutaj rozszerzyć wiele rzeczy i przejść przez różne opcje. Sprawdź plik readme aby zobaczyć wszystkie dostępne opcje.

Ten HtmlMinifier jest kompletny i bezpieczny. Proces minifikacji obejmuje 3 kroki:

1. Zastąp krytyczną zawartość tymczasową symbolem zastępczym.
2. Uruchom strategie minifikacji.
3. Przywróć oryginalną zawartość.

Sugerowałbym, abyś buforował dane wyjściowe swoich widoków. Proces minifikacji powinien być jednorazowy. Lub zrób to na przykład na podstawie interwału.

W tym czasie nie są tworzone jasne testy porównawcze. Jednak minifier może zmniejszyć rozmiar strony o 5-25% w zależności od Twojego znacznika!

Jeśli chcesz dodać własne strategie, możesz skorzystać addPlaceholderz addMinifiermetod i.

Mam gist GitHub zawierający funkcje PHP do minifikacji plików HTML, CSS i JS → https://gist.github.com/taufik-nurrohman/d7b310dea3b33e4732c0

Oto jak zminimalizować wyjście HTML w locie za pomocą bufora wyjściowego:

<?php

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

ob_start('minify_html');

?>

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

<?php echo ob_get_clean(); ?>

Jeśli chcesz usunąć wszystkie nowe wiersze na stronie, użyj tego szybkiego kodu:

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

Dzięki Andrew . Oto, co zrobił, aby użyć tego w cakePHP:

1. Pobierz minify-2.1.7
2. Rozpakuj plik i skopiuj podfolder min do folderu dostawcy ciasta

3. Tworzy MinifyCodeHelper.php w widoku / pomocniku ciasta w następujący sposób:

   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. Włączono mojego pomocnika w AppController

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

5 ... Voila!

Mój wniosek: jeśli deflate i moduły nagłówków Apache są wyłączone na twoim serwerze, zysk jest o 21% mniejszy i 0,35s plus w żądaniu kompresji (ta liczba była w moim przypadku).

Ale gdybyś włączył moduły Apache, skompresowana odpowiedź nie ma znaczącej różnicy (dla mnie 1,3%), a czas kompresji jest taki sam (0,3 s dla mnie).

Więc ... dlaczego to zrobiłem? ponieważ dokument mojego projektu jest w komentarzach (php, css i js), a mój użytkownik końcowy nie musi tego widzieć;)

Możesz użyć dobrze przetestowanego minifier Java, takiego jak HTMLCompressor , wywołując go za pomocą passthru( exec).
Pamiętaj, aby przekierować konsolę za pomocą2>&1

Może to jednak nie być przydatne, jeśli chodzi o szybkość. Używam go do statycznego wyjścia php