Ecco alcuni consigli utili per gli acquisti

1. Fare tante prove con php -a

Quando programmiamo possiamo spesso avere dubbi su come scrivere un ciclo o quale sia il valore di ritorno di una funzione. Per questo possiamo utilizzare un potente strumento messo a disposizione dalla nostra installazione PHP. Se apriamo una console e scriviamo "php -a" ci troveremo davanti ad una shell interattiva per fare le nostre prove senza necessità di creare file ed eseguirli.

2. empty vs. isset vs. is_null

Molti programmatori non conoscono la differenza tra queste tre funzioni:

• empty
• isset
• is_null

e le considerano intercambiabili tra di loro. Ovviamente questo non corrisponde alla verità. Ad esempio se consideriamo questo codice:

$var = 0;
var_dump(empty($var));
var_dump(isset($var));

notiamo che i due var_dump ci ritornano true. Questo significa che la variabile è instanziata ma è considerata vuota. Per approfondire il tema vi consiglio di leggere il manuale di PHP per le funzione isset, empty e is_null, fare tante prove e dare un'occhiata a questa comparativa.

3. Operatore ternario

Agli occhi di un newbie l'operatore ternario può sembrare ostico. In realtà la sua sintassi è semplice, concisa ed elegante. Ecco alcuni esempi di utilizzo comuni:

public function generic($param = null)
{
	(isset($param)) ? : $param = false;

	...

	return (isset($value)) $value : false;
}

4. Suddividere la condizione di un if

Se siamo davanti ad un if con una condizione particolarmente complessa può essere utile suddividerla in vari passi per migliorare la leggibilità del nostro codice.

// old version
if (isset($var) &&
	getSomething($var) == $value &&
	getAnotherThing($var) == $otherValue) {
	...
}

// new version
$cond = isset($var);
$cond = $cond && (getSomething($var) == $value);
$cond = $cond && getAnotherThing($var) == $otherValue;
if ($cond) {
	...
}

5. Se possibile utilizzare l'operatore identico

Se ci troviamo davanti ad un if in cui nella condizione conosciamo a priori il tipo dei due operandi è sempre meglio utilizzare l'operatore identico ("==="):

// old version
$x = true;
if ($x == true) {
	...
}

$x = (int) 0;
if ($x == 0) {
	...
}

// new version
$x = true;
if ($x === true) {
	...
}

$x = (int) 0;
if ($x === 0) {
	...
}

Questo serve per:

• migliorare la precisione della risposta
• migliorare le performance (un 30%)

6. Condizione del for fuori della sua definizione

Spostare la condizione di uscita del for fuori dalla sua definizione può migliorare del 50000% le sue performance per un array di 1000 elementi! Questo perchè per ogni iterazone si esegue un'altra volta il controllo e questo può essere pesante in termini di risorse utilizzate.

// old version
for ($i=0; $i < count($x); $i++) {
	...
}

// new version
$limit = count($x);
for ($i=0; $i < $limit; $i++) {
	...
}

Inoltre, se vogliamo limare ancora leggermente le performance, sizeOf() è leggermente più veloce della funzione count().

7. Print vs. echo vs. echo concatenato con virgole

Ormai è raro vedere codice con un print ma meglio specificare che un echo è più rapido di un 30% e possiamo migliorare ulteriormente la velocità concatenando dentro del echo con una virgola invece che con il punto.

// peggiore
print 'Hello' . ' ' . 'Alessio Mavica';

// migliore
echo 'Hello' . ' ' . 'Alessio Mavica';

// ottimo
echo 'Hello' , ' ' , 'Alessio Mavica';

8. Leggenda metropolitana delle virgolette semplici vs. doppie virgolette

Con le ultime versioni di PHP l'uso di risorse delle virgolette semplici e delle doppie virgolette è praticamente uguale.

echo 'Hello Alessio Mavica';

È praticamente uguale a:

echo "Hello Alessio Mavica";

Rimane la differenza che dentro delle doppie virgolette possiamo utilizzare variabili.

9. Inizializzare le nostre variabili

È una buona pratica inizializzare le nostre variabili prima di utilizzarle, soprattutto se ci troviamo in una situazione come questa:

if ($cond) {
	$var = array('Hello', 'Alessio', 'Mavica');
}

foreach ($var as $item) {
	echo $item . PHP_EOL;
}

Se $cond non è true questo script genererà un notice e un warning.

Ecco lo script corretto:

// variable initialization
$var = array();

if ($cond) {
	$var = array('Hello', 'Alessio', 'Mavica');
}

foreach ($var as $item) {
	echo $item . PHP_EOL;
}

Semplicemente inizializzando la nostra variabile ci troveremo senza errori e, soprattutto, con un codice più corretto, mantenibile e chiaro.

10. PHP.net

Last but not least... consultiamo sempre la documentazione di PHP perché non è segno di ignoranza ma di voglia di migliorare le nostre abilità e conoscenze in PHP.

PHP.NET DOCET!

CONCLUSIONI

Programmare in PHP è semplice e comodo ma è necessario farlo bene per scrivere codice corretto, pulito e mantenibile. Se poi il nostro codice è anche elegante... abbiamo raggiunto il nostro obiettivo

Enabling E_NOTICE during development has some benefits. For debugging purposes: NOTICE messages will warn you about possible bugs in your code. For example, use of unassigned values is warned. It is extremely useful to find typos and to save time for debugging. NOTICE messages will warn you about bad style. For example, $arr[item] is better to be written as $arr['item'] since PHP tries to treat "item" as constant. If it is not a constant, PHP assumes it is a string index for the array.

Con l'inclusione di E_STRICT nel E_ALL in PHP 5.4 no avremo scuse per non guardare questi messaggi.

PERCHÉ UTILIZZARE E_STRICT?

E_STRICT ci permette sviluppare codice più pulito e assicura una maggiore interoperabilità e compatibilità con versioni successive di PHP.

I 5 ERRORI PIÙ COMUNI USANDO E_STRICT

Di recente ho attivato l'E_STRICT in una web per aggiornare il codice e questi sono i 5 errori più frequenti con cui mi sono trovato faccia a faccia:

1. Funzioni obsolete

PHP ci indica se una funziona è deprecata. Ecco qui la lista delle obsolete per la versione 5.3: http://php.net/manual/en/migration53.deprecated.php

Errore:

PHP Deprecated: Function xxx() is deprecated

2. Static

Molte volte dimentichiamo di porre la keyword "static" nella definizione di una funzione che poi utilizziamo con class::method

Errore:

Non-static method XXX should not be called statically, assuming $this from incompatible context

3. Overloading

In PHP non esiste l'overloading, lo possiamo solo "simulare" con __call pero come tutti i metodi magici è abbastanza costoso. In altre parole non possiamo dichiarare due funzioni con lo stesso nome che si differenziano solo per la firma (parametri). Dunque nel caso dell'overriding (sovrascrittura di un metodo di una classe padre che abbiamo ereditato) dobbiamo utilizzare gli stessi parametri o, al massimo, aggiungerne altri.

Errore:

Declaration of XXX should be compatible with that of YYY

4. Passare una variabile a una funzione che accetta un parametro per referenzia

Non è possibile non passare una variabile a una funzione che accetta un parametro per referenzia. Concretamente non possiamo fare questo:

array_pop(explode('-', 'hello-world'));

Dobbiamo salvare il risultato dell'explode in una variabile e successivamente passarla all'array_pop:

$hola = explode('-', 'hello-world');
array_pop($var);

Ecco alcune funzioni che accettano parametri per referenzia: array_shift, array_unshift, array_pop, array_push, current, end...

Errore:

Only variables should be passed by reference

5. Creare un oggetto generico

A volte per passare dati via json o per comodità creiamo un oggetto generico senza inizializzarlo. Per esempio:

$obj->propierty = true;

In questo caso dobbiamo inizializzare l'oggetto in questo modo:

$obj = new stdClass();
$obj->propierty = true;

Errore:

Creating default object from empty value

CONCLUSIONI

L'uso di E_STRICT ci permetterà di sviluppare applicazioni compatibili con il futuro e ci aiuta a apprendere dettagli del PHP che non conoscevamo.

Quali sono i più famosi e quali sono questi problemi ricorrenti? In questo articolo proporrò una lista dei più famosi design pattern associati al problema che risolvono così da trovarli rapidamente.

PRO E CONTRO DELL'UTILIZZO DI DESIGN PATTERN

Anzitutto si deve sottolineare che l'utilizzo di design pattern ha lati positivi e negativi. Riassumiamo pro e contro:

PRO:

• soluzioni collaudate
• architettura più semplice da decodificare (reverse engineering)

CONTRO:

• non sempre rappresentano la soluzione più ottimizzata
• capire quando è possibile utilizzarli (necessitano un minimo d'esperienza)

I DESIGN PATTERN PIÙ NOTI E CHE PROBLEMA RISOLVONO

Adapter

Adattare un nuovo oggetto a un sistema di classi già esistenti e stabili.

Builder

Delegare la costruzione di un oggetto a un'altra classe. Necessario soprattutto per oggetti complessi la cui costruzione dipende da vari fattori.

Decorator

Aggiungere o modificare funzionalità di un oggetto senza modificare la sua struttura interna.

Delegate

Modificare un oggetto estraendo una parte di codice complesso ma indipendente per creare una nuova classe. Consigliato nel caso di if o switch complessi.

Façade

Creare un nuovo livello (classe) per nascondere la complessità di un oggetto.

Factory

Creare un'interfaccia che crea un'istanza di un oggetto senza specificare a priori la classe.

Interpreter

Analizza gli elementi chiave di una entità e ne fornisce una interpretazione (per esempio per creare un sistema di template).

Iterator

Aiuta a costruire oggetti i cui elementi possono essere manipolati in maniera simile ad un array.

Mediator

Si utilizza quando dobbiamo modificare più oggetti simili. La classe mediator si occupa di modificarle tutte.

Observer

Serve a creare oggetti che osservano altri oggetti per fornire notizie sullo stato di quest'ultimi.

Prototype

Serve a creare un oggetto che clona un altro per risparmiare risorse (per esempio per oggetti con costruttori molto pesanti e, in parte, inutili).

Proxy

Crea un oggetto che si interpone in maniera trasparente tra altri due per controllare l'accesso o sovrascrivere funzionalità.

Singleton

Serve a creare un'unica istanza di un oggetto (per esempio per l'accesso a una DDBB).

Strategy

Si utilizza se isoliamo un algoritmo in un oggetto che sappiamo possa variare dinamicamente e ne creiamo diverse classi.

Template

Semplicemente creare una classe astratta che fornisca una serie di metodi che utilizzeranno le classi che la ereditano.

Visitor

Per minimizzare le modifiche a una classe (principio open/close) si crea un'altra che viene chiamata ogniqualvolta si istanzi la prima. E' come se "estendessimo" la classe virtualmente.

CONCLUSIONI

I design pattern sono molto potenti e utili. Ogni buon programmatore dovrebbe conoscerli e utilizzarli al meglio. Spero che questa mini-guida vi aiuti a riconoscere quando è possibile utilizzarne uno per seguire il principio del "non reinventare la ruota".

Questo processo prende il nome di Refactoring, parola che molti odiano in quanto prevede l'impiego di risorse per qualcosa che non è un prodotto completo o una release. È naturale, dunque, che il vostro Product Owner non lo veda di buon'occhio. Sebbene in lotta continua per il Time To Market gli sviluppatori dovrebbero prestare la dovuta attenzione a questa fase giacché si potrebbe arrivare alla classica situazione di stallo in cui modificare il codice spaghetti a cui si è arrivati presuppone un costo maggiore del refactoring stesso.

Dunque quali sono le linee guida per un buon Refactoring? Cerchiamole insieme...

QUAL'È LA DEFINIZIONE DI REFACTORING

Ufficialmente possiamo definire il refactoring come il processo per alterare il funzionamento interno di un'applicazione senza modificare il suo comportamento esterno.

GLI OBBIETTIVI

• Minore complessità
• Maggiore leggibilità
• Migliorare la fase di manutenzione
• Migliorare la scalabilità

Ecco dunque un decalogo per portare a termine in maniera soddisfacente il lavoro di refactoring:

1. CREARE NUOVI METODI
2. INTRODURRE NUOVE VARIABILI ESPLICATIVE
3. RINOMINARE METODI
4. MUOVERE ELEMENTI
5. CREARE NUOVE CLASSI
6. NASCONDERE DELEGATI
7. TRASFORMARE ARRAY IN OGGETTI
8. CAMBIARE EREDITÁ PER DELEGATI
9. ULTIME TRE REGOLE

1. CREARE NUOVI METODI

Supponiamo di avere questa funzione che calcola il prezzo totale di un articolo comprese tasse e spese di spedizione:

public function getTotalPrice($id_product)
{
	$product_price = $this->getProductPrice($id_product);
	$product_price_taxed = $this->tax * $product_price;
	$product_price_shipping = $this->getProductShipping($id_product);

	$product_price_total =
		$product_price_taxed + $product_price_shipping;

	return $product_price_total;
}

Possiamo isolare la linea per il calcolo delle imposte in un nuovo metodo.

// line 4 modified
$product_price_taxed = $this->getPriceTaxed($product_price);

// new method
public function getPriceTaxed($product_price)
{
	return $this->tax * $product_price;
}

2. INTRODURRE NUOVE VARIABILI ESPLICATIVE

Soprattutto nei casi di cicli con condizioni particolarmente complesse è consigliabile creare nuove variabili esplicative.

if (strpos($_SERVER['SERVER_NAME'], 'local') === FALSE)
	// do something

Ed ecco qui la versione con una nuova variabile esplicativa:

$is_local = strpos($_SERVER['SERVER_NAME'], 'local');

if ($is_local === FALSE)
	// do something

3. RINOMINARE METODI

Odio profondamente quegli sviluppatori che creano metodi con nomi assolutamente inutili perché generici: get, set, getForm, setValue...

I nomi dei metodi, come i titoli dei giornali, devono essere scelti in modo opportuno: esplicativi ma non troppo lunghi.

4. MUOVERE ELEMENTI

Un altro passo per un buon refactoring è trovare la giusta posizione per metodi e attributi. Supponiamo, ad esempio, di aver creato la classe car con la variabile piston e che successivamente abbiamo creato la classe motor. È chiaro che la variabile piston sia un attributo della classe motor e non della classe car. È dunque nella fase di refactoring che dovremmo riorganizzare le giuste associazioni tra classi, attributi e metodi.

5. CREARE NUOVE CLASSI

Se abbiamo un costrutto if (o switch) del tipo:

public class car
{
	private $motor;

	public function __constructor($motor)
	{
		$this->motor = $motor;
	}

	public function getMotor()
	{
		if($this->motor == 'DIESEL')
			return $this->getDieselPrice();
		elseif($this->motor == 'UNLEADED')
			return $this->getUnleadedPrice();
	}
}

Allora è molto probabile che dobbiamo creare tre nuove classi:

• una astratta motor
• una dieselMotor che estende motor
• una unleadedMotor che anch'essa estende motor

6. NASCONDERE DELAGATI

Se abbiamo una linea di codice del tipo:

$fuelType = $car->getMotor()->getFuelType();

In cui il metodo getMotor è il seguente:

public function getMotor()
{
	return $this->motor;
}

Dobbiamo modificarlo in modo tale da ritornare direttamente l'attributo di cui abbiamo bisogno:

public function getMotor()
{
	return $this->motor->getFuelType();
}

Tutto questo per seguire la Legge di Demetra secondo la quale non dobbiamo affidarci alla struttura interna di un altro oggetto perché, in caso di modifiche, dovremmo modificare più parti di codice.

7. TRASFORMARE ARRAY IN OGGETTI

Supponiamo di avere una classe car siffatta:

public class car
{
	private $details;

	public function __constructor($details)
	{
		$this->details = $details;
	}
}

Dunque per creare l'oggetto car dobbiamo passare come parametro un array con le caratteristiche dell'auto. Se vogliamo ora ritornare un dettaglio dell'auto dobbiamo leggerlo dall'array $details.
La maniera più corretta per inizializzare un oggetto e immagazzinare i suoi attributi è creare una variabile per ogni caratteristica come nell'esempio seguente:

public class car
{
	private $motor;
	private $brand;
	private $model;

	public function __constructor($motor, $brand, $model)
	{
		$this->motor = $motor;
		$this->brand = $brand;
		$this->model = $model;
	}
}

8. CAMBIARE UNA EREDITÀ CON DELEGATI

Supponiamo di avere una classe che implementa un'interfaccia per effettuare il log dell'applicazione:

public class car extends Logger
{
	public function run()
	{
		...
		$this->log(...);
	}
}

Il modo più corretto per fare tutto ciò è passare l'oggetto logger come parametro nel momento di creare l'oggetto car e accedere quindi alla variabile senza estendere nessuna classe. Anche in questo caso seguiamo la legge di Demetra.

public class car
{
	private $logger;

	public function __contruct($logger)
	{
		$this->logger = $logger;
	}
	public function run()
	{
		...
		$this->logger->log(...);
	}
}

9. ULTIME TRE REGOLE

Gli ultimi tre consigli per un buon refactoring sono:

1. eliminare codice ridondante
2. scrivere blocchi di codice brevi
3. separare concetti diversi

CONCLUSIONI

Il lavoro di refactoring deve essere incluso in ogni buon progetto ed è fondamentale per rendere l'applicazione semplice e mantenibile e quindi evitare di arrivare ad avere un codice spaghetti che è impossibile da sbrogliare.

• requisiti poco chiari (o idee poco chiare da parte dello sviluppatore) in fase di progettazione
• poca conoscenza di questi concetti

Vediamo dunque di fare un po' di chiarezza.

COS'È UN'INTERFACCIA

La definizione più chiara è che un'interfaccia è un contratto.

Caratteristiche:

• tutte le classi che implementano un'interfaccia devono sviluppare tutti i metodi che sono stati definiti
• per ogni metodo si definisce solo la firma
• i metodi possono essere solo pubblici
• una classe può implementare più di un'interfaccia
• un'interfaccia può essere utilizzata per il Type Hinting

interface logsInterface
{
  public function log($message, $priority = null);
}

COS'È UNA CLASSE ASTRATTA

E' una classe "padre" che deve essere ereditata per poter essere utilizzata. Le classi che la ereditano differiscono tra di loro solo nei metodi astratti e possono accedere ai metodi della classe padre mediante la keyword parent.

Caratteristiche:

• non può essere instanziata
• i metodi possono essere astratti (non implementati)
• i metodi possono non essere astratti (implementati)
• una classe può ereditare solo una classe astratta

abstract class logsAbstract
{
    private $variable;
    abstract public function logMethod();

    public function getVariable()
    {
        return $this->variable;
    }
}

TABELLA RIEPILOGATIVA INTERFACE VS ABSTRACT CLASS

In generale se una classe astratta contiene solo metodi astratti la stiamo utilizzando come un'interfaccia.

CONCLUSIONI

Le classi astratte si utilizzano per condividere funzioni.
Le interfacce si utilizzano per condividere come va fatto qualcosa.

LINKS

• Why are interfaces widely ignored in the PHP world and what use do they have when working with symfony?
• Difference between abstract classes and interfaces
• Esempio di interface e abstract class

Il problema che ci si presenta è quello dei name collitions, cioè della confusione che si puó produrre parlando di due cose diverse che hanno lo stesso nome. Nel caso del PHP si potrebbero produrre sovrascrivendo nomi di classi, funzioni o costanti.

La soluzione nel PHP è tanto semplice quanto geniale e si chiama namespaces. Inoltre se si utilizza nella nuova versione del Zend Framework (2.0) sarà qualcosa di buono

Ufficialmente i namespaces servono per incapsulare. Questo significa che possiamo creare pacchetti di classi sicuri che non produrremo name collitions. Un esempio vale più di mille parole:

ESEMPIO:

/*FILE file1.php*/
namespace namespace1;
class testClass {
        function whoAmI (){
                return 'file1' . PHP_EOL;
        }
}

/*FILE file2.php*/
namespace namespace2;
class testClass {
        function whoAmI() {
                return 'file2' . PHP_EOL;
        }
}

/*FILE test.php*/
require_once('./file1.php');
require_once('./file2.php');

$class1 = new \namespace1\testClass();
echo $class1->whoAmI();

$class2 = new \namespace2\testClass();
echo $class2->whoAmI();

/*********
Output:
file1
file2
*********/

Come possiamo vedere abbiamo utilizzato due classi con lo stesso nome senza generare collisioni. Lo stesso vale utilizzando costanti e funzioni.

VANTAGGI:

Dunque, quali sono i vantaggi?

1. codice più chiaro
2. migliore organizzazione se stiamo sviluppando un'applicazione molto grande
3. iniziare a utilizzare un nuovo elemento che sarà il nostro pane quotidiano nei prossimi anni

SUB-NAMESPACES:

A differenza dei packages di Java nel PHP possiamo creare diversi livelli di namespace affinché il nostro codice risulti più organizzato.

\namespace1\subnamespace\subsubnamespace

UTILIZZARE UN NAMESPACE (use):

Negli esempi anteriori abbiamo utilizzando un backslash all'inizio del namespace. Questo significa che il namespace che utilizzeremo è di tipo GLOBALE. In altre parole i path che utilizzeremo si riferiscono alla root del nostro "albero" di namespaces. Una maniera più semplice di utilizzare i nostri namespaces è definire un "livello" che utilizzeremo attraverso la parola riservata use.

Ipotizziamo di avere la classe class1 nel seguente namespace:

\namespace1\subnamespace\subsubnamespace

Per poterla instanziare dovremmo utilizare questo codice:

$class = new \namespace1\subnamespace\subsubnamespace\class1();

Lavorando con il use possiamo semplicemente scrivere:

use \namespace1\subnamespace\subsubnamespace;
$class = new subsubnamespace\class1();

ALIAS:

L'alias è un costrutto molto utile per rendere il nostro codice più semplice e facile da mantenere. Supponiamo che nell'esempio anteriore il nome del namespace subsubnamespace non ci piaccia o che sia troppo lungo, possiamo utilizzare la seguente sintassi:

use \namespace1\subnamespace\subsubnamespace as newname;
$class = new newname\class1();

VARIABILE __NAMESPACE__:

Per sapere in che namespace ci troviamo attualmente possiamo utilizzare la variabile __NAMESPACE__

CONCLUSIONI:

Questo post non vuole essere una trattato completo sui namespaces ma mostrare una panoramica delle sue capacità.

Vi lascio 3 links molto interessanti su questo tema:

• Manual PHP
• Post di un altro blog in inglese
• Un altro blog che tratta il tema in maniera molto esaustiva ma in spagnolo

La idea è semplice:
Conservare l'output in una variabile e ritornarla in un'unica volta.

VANTAGGI:

I vantaggi di utilizzare l'Output Buffering Control sono molteplici:

• Maggiore velocità
• Minor utilizzo di banda
• Maggior controllo
• Possibilità di ridirezionare l'output a un file
• Manipolare l'output
• Configurare header e cookie in qualsiasi punto del codice

FUNZIONI:

La funzione per iniziare a utilizzare Output Buffering Control è ob_start. Possiamo passare un parametro per definire la funzione callback.
La più utilizzata è ob_gzhandler che consente la compressione del nostro output mediante l'algoritmo gzip.

Possiamo eliminare l'output buffering con due funzioni:

• ob_end_clean: libera l'output buffering
• ob_end_flush: invia l'output buffering al client e termina l'esecuzione

Altre funzioni utili sono:

• ob_clean: libera il buffer
• ob_get_clean: ritorna il buffer per salvarlo in una variabile e lo libera
• ob_get_flush: ritorna il buffer al client e lo libera
• ob_get_length: ritorna la lunghezza attuale del buffer
• ob_get_level: ritorna il libello di annidamento del meccanismo di buffer (si possono annidare più buffer)
• ob_get_status: ritorna lo stato del buffer attuale (o di tutti se passiamo il parametro TRUE)
• ob_implicit_flush: di default se non chiamiamo la funzione ob_end_flush si esegue automaticamente alla fine dello script
• output_add_rewrite_var: aggiunge una variabile (nome=valore) in ogni URL che non sia assoluta e un campo hidden in ogni form
• output_reset_rewrite_vars: ristabilisce i valori de default del meccanismo di riscrittura delle URL

ESEMPI:

<php
ob_start();
echo "Hello World!";
ob_end_flush();
?>

Per realizzare la compressione dell'output dobbiamo passare il parametro ob_gzhandler alla funzione ob_start:

<?php
ob_start('ob_gzhandler');
echo "Hello World!";
ob_end_flush();
?>

TIPS:
Possiamo chiamare una funzione callback che pulisca tutto l'output prima di inviarlo al client.
Ecco alcune più frequenti:
- rimuovere spazi bianchi ripetuti:

trim(preg_replace('/\s+/', ' ', $buffer));

- codificare HTML entities. Per esempio:

$buffer = str_replace('&', ' &;amp;', $buffer);

- ridirigere l'output a un file

PERFORMANCE:
Utilizzando questo semplice script ho registrato un miglioramento del 10% nella velocità ed il peso della pagina è passato da 244.2KB a 612B.

<?php
ob_start('ob_gzhandler');
for ($j=1; $j <= 5; $j++)
{
list($usec, $sec) = explode(" ",microtime());
$debut[$j] = ((float)$usec + (float)$sec);

echo str_repeat("0123456789",5000) . '<br>' ;

list($usec, $sec) = explode(" ",microtime());
$fin[$j] = ((float)$usec + (float)$sec);
}
echo '<br><br>TEST PERFORMANCE</br><br>';

$total = 0;
for ($j=1; $j <= 5; $j++)
$total += round($fin[$j]-$debut[$j], 5) . '<br>';

echo 'TOTAL: '. $total;

ob_end_flush();
?>

]]> http://www.alessiomavica.com/it/2011/08/24/php-output-buffering-control/feed/ 0