Questa ulteriore classe, descrive come gestire più files in un'unico archivio
mediante serializzazione:
codice:
<?php
class gz_archive {

    /* Inizializza le variabili */
    var $source;
    var $dest;
    var $level;
    var $pointer;
    var $gzdata;
    var $data;
    var $status = TRUE;
    var $key = 0;
    var $files = array();
    var $contents;
    var $count;
    var $fcontents;
    var $path;

    function gz_archive($path)
    {
        $this->path = $path;
    }

    function compress($source, $level)
    {
        /* Inizializza le variabili */
        $this->source = $source;
        $this->level = $level;
        
        /* Controlla che $this->source sia un array */
        if(!is_array($this->source)) exit("The source input must be an array");
        
        /* Controlla che i files indicati nell'array esistano */
        foreach($this->source AS $key => $value)
        {
            if(!is_file($this->source[$key])) exit(print_R($this->source[$key]) . " isn't a file");
        }

        /* Arrotonda il livello di compressione */
        $this->level = round($this->level);

        /* Controlla il livello e se è troppo grande, lo porta al massimo */
        if($this->level == 'MAX' OR $this->level > 9) $this->level = 9;

        /* Controlla il livello e se è troppo piccolo, lo porta al minimo */
        if($this->level == 'MIN' OR $this->level < 0) $this->level = 0;
        
        /* Crea un array nel quale ci sarà il contenuto dei files */
        $this->count = count($this->source);
        
        while($this->data = file_get_contents($this->source[$this->key]))
        {
            print $this->data;
            $this->fcontents[$this->source[$this->key]] = $this->data;
            $this->key++;
            if($this->key >= $this->count) break;
        }
        
        /* Serializza l'array */
        $this->data = serialize($this->fcontents);

        /* Comprime i dati del file d'origine */
        $this->gzdata = gzcompress($this->data, $this->level);

        /* Scrive i dati compressi nel file di destinazione */
        $this->status = file_put_contents($this->path, $this->gzdata);

        /* Ritorna i valori positivi e negativi in base all'esito dell'operazione */
        if($this->status) return TRUE; else return FALSE;
    }
    
    function decompress()
    {
        /* Controlla se il file esiste o meno */
        if(!is_file($this->path)) exit("File doesn't exists");
        
        /* Riceve l'array */
        $this->data = file_get_contents($this->path) or exit("Cannot read the file");

        /* Lo decomprime */
        $this->data = gzuncompress($this->data);
        
        /* E restituisce l'array */
        $this->data = unserialize($this->data);
        
        /* Installa i files */
        foreach($this->data AS $filename => $contents)
        {
            print $contents;
            if(!file_put_contents($filename, $contents)) $this->status = FALSE;
        }

        /* Ritorna i valori positivi e negativi in base all'esito dell'operazione */
        if($this->status) return TRUE; else return FALSE;
    }
}
?>
Il funzionamento è più o meno simile rispetto a quello della classe precedente, qui spiegherò
le differenze... Trattiamo prima la compressione:

codice:
/* Controlla che $this->source sia un array */
if(!is_array($this->source)) exit("The source input must be an array");

/* Controlla che i files indicati nell'array esistano */
foreach($this->source AS $key => $value)
{
    if(!is_readable($this->source[$key])) exit(print_R($this->source[$key]) . " isn't a file or is't readable");
}
due controlli: Il primo controlla che $this->source sia un'array,
il secondo, che i percorsi indicati in esso siano leggibili.

codice:
/* Crea un array nel quale ci sarà il contenuto dei files */
$this->count = count($this->source);

while($this->data = file_get_contents($this->source[$this->key]))
{
    $this->fcontents[$this->source[$this->key]] = $this->data;
    $this->key++;
    if($this->key >= $this->count) break;
}

/* Serializza l'array */
$this->data = serialize($this->fcontents);
la sostanziale differenza stà proprio qua:
Count() Conta gli elementi di un'array, in questo caso quello
contenente i percorsi dei files da comprimere.

Il while esegue l'operazione di recupero dei files dal percorso specificato, e
li memorizza in $this->fcontents, forse vi sarà di più difficile comprensione,
questo: $this->fcontents[$this->source[$this->key]] = $this->data; che memorizza
in $this->fcontents['percorso_del_file'] il suo contenuto.

Infine con serialize() Serializziamo l'array contenente
i files ed il loro percorso.
Poi crea l'archivio e vi mette dentro il contenuto compresso della serializzazione.


Per quanto riguarda la decompressione dell'archivio, il codice è mutato qui:
codice:
/* E restituisce l'array */
$this->data = unserialize($this->data);

/* Installa i files */
foreach($this->data AS $filename => $contents)
{
    print $contents;
    if(!file_put_contents($filename, $contents)) $this->status = FALSE;
}
In quanto, dopo che l'archivio è stato decompresso, bisogna deserializzarlo,
con la funzione unserialize(), che in questo caso restituirà l'array
precedentemente creato.
Il foreach, in questo caso, serve a 'installare' i files, nel percorso salvato
durante la creazione dell'archivio, e in caso di un qualsiasi errore, non blocca
lo script ma restuirà FALSE.


Questo metodo di compressione, come ho detto in precedenza, non è visualizzabile
con i programmi di gestione archivi, ma esiste la funzione gzencode()
che permette di farlo.

Esistono inoltre altri tipi di comrpessione GZ, Come quello DEFLATE:
Per creare archivi così, bisogna utilizzare la funzione gzdeflate()
che ha come argomenti i dati da comprimere e il livello di compressione.
Per poi decomprimere questo tipo di archivio, utilizzaremo la funzione gzinflate()
che ha come argomenti, i dati e (opzionale) la lunghezza del file.

Ora scriverò un paio di esempio per quanto riguarda l'utilizzo delle classi, sia
per i singoli che per gli archivi:
codice:
include("./PaTeR_Class.php");
// Esempio per la creazione di un file singolo
$singlegz = new gz_single();
$status = $singlegz->compress(".\File_di_origine.txt", "Nuovo_archivio_gz.txt.gz", /* Livello di compressione */);
if(!$status) print "Errore durante la creazione dell'archivio gz";

// Esempio per la decompressione dell'archivio gz
$singlegz = new gz_single();
$status = $singlegz->decompress("File_gz_da_decomprimere.gz", "Nuovo_file_decompresso.txt");
if(!$status) print "Errore durante la decompressione dell'archivio gz";

// Esempio creazione di un'archivio gz
$archivegz = new gz_archive(".\Mio_archivio_gz.gz");
$files = array(".\file1.txt", ".\file2.exe", ".\file3.doc");
$status = $archivegz->compress($files, /* Livello di compressione */);
if(!$status) print "Errore durante la creazione dell'archivio gz";

// Esempio di estrazione di un'archivio gz
$archivegz = new gz_archive(".\Mio_archivio_gz.gz");
$status = $archivegz->decompress();
if(!$status) print "Errore durante la decompressione dell'archivio gz";

Con tutto ciò, ho pensato di poter essere stato utile a qualcuno...
Perchè a volte può essere utile comprimere files o stringhe, specialmente quando
si lavora con file anche abbastanza grossi.
Ciauuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu...