extension=php_zip.dll

./configure --prefix=/usr/local/php4 ... --with-zip
make
make install

cd /répertoire/des/sources/de/l/extension
phpize
./configure
make
make install

extension=zip.so

<style type="text/css">
<!--
table.zip_details {
    border: 3px double black;
    border-collapse: collapse;
}

table.zip_details td,
table.zip_details th {
    border: 1px solid black;
}

table.zip_fichiers td,
table.zip_fichiers th {
    border: 0px none;
}
-->
</style>

<?php
function formater_taille($taille) {
    $unites = array('o', 'ko', 'Mo', 'Go');

    for ($u = count($unites); $u >= 0; $u--) {
        if (isset($unites[$u]) && $taille >= 1024 * pow(1024, $u - 1)) {
            $taille = $taille / pow(1024, $u);
            $unite = $unites[$u];
            break;
        }
    }

    if ($u > 0) {
        return number_format($taille, 2, ',', ' ') . ' ' . $unite;
    } else {
        return $taille . ' ' . $unite;
    }
}

function afficher_zip($archive) {
    if (($zip = zip_open($archive)) === FALSE) {
        return FALSE;
    }
    echo '<table class="zip_details">';
    echo '<tr><th colspan="2">' . $archive . '</th></tr>';
    echo '<tr><td>Taille :</td><td>' . formater_taille(filesize('sources.zip')) . '</td></tr>';
    $nbEntrees = 0;
    echo '<tr>
        <td>Fichiers archivés :</td>
        <td><table class="zip_fichiers">
        <tr>
            <th>Nom</th>
            <th>Taille compressée</th>
            <th>Taille non compressée</th>
        </tr>';
    while ($entree = zip_read($zip)) {
        echo '<tr>
            <td>' . zip_entry_name($entree) . '</td>
            <td align="center">' . formater_taille(zip_entry_compressedsize($entree)) . '</td>
            <td align="center">' . formater_taille(zip_entry_filesize($entree)) . '</td>
        </tr>';
        $nbEntrees++;
    }
    echo '</table></td></tr>';
    echo '<tr><td>Nombre de fichiers archivés :</td><td>' . $nbEntrees . '</td></tr>';
    echo '</table>';
    zip_close($zip);
    return TRUE;
}

# Exemple d'utilisation
afficher_zip('sources.zip');
?>

function mkdir_recursif($dir) {
    $parties = preg_split('#/|' . preg_quote(DIRECTORY_SEPARATOR) . '#', $dir, -1, PREG_SPLIT_NO_EMPTY);
    $base = '';
    foreach ($parties as $p) {
        if (!file_exists($base . $p)) {
            mkdir($base . $p);
        }
        $base .= $p . DIRECTORY_SEPARATOR;
    }
}

function extractTo($archive, $destination, $ecrase = FALSE, $fichiers = NULL) {
    if (($zip = zip_open($archive)) === FALSE) {
        die(var_dump($zip));
        return FALSE;
    }
    if (!file_exists($destination)) {
        mkdir_recursif($destination);
    }
    while ($entree = zip_read($zip)) {
        $fichier = zip_entry_name($entree);
        if (is_array($fichiers) && !in_array($fichier, $fichiers)) {
            continue;
        }
        if (zip_entry_open($zip, $entree)) {
            $contenu = zip_entry_read($entree, zip_entry_filesize($entree));
            zip_entry_close($entree);
            if ($ecrase || !file_exists($destination . DIRECTORY_SEPARATOR . $fichier)) {
                if (strpos($fichier, '/') !== FALSE) {
                    mkdir_recursif($destination . DIRECTORY_SEPARATOR . dirname($fichier));
                }
                $fp = fopen($destination . DIRECTORY_SEPARATOR . $fichier, 'w');
                fwrite($fp, $contenu);
                fclose($fp);
            }
        } else {
            zip_close($zip);
            return FALSE;
        }
    }
    zip_close($zip);
    return TRUE;
}

# Exemples d'utilisation
# Extraction de l'ensemble des fichiers qui composent l'archive
extractTo('sources.zip', '/home/julp/www/zip');
# Extraction limitée aux fichiers fichier1 et fichier2. S'ils existent déjà ils seront écrasés.
extractTo('mon_archive.zip', '/home/julp', TRUE, array('fichier1', 'fichier2'));

extension=php_zip.dll

./configure --prefix=/usr/local/php5 ... --enable-zip
make
make install

cd /répertoire/des/sources/de/l/extension
phpize
./configure
make
make install

extension=zip.so

class ZipArchive
{
    /* Constantes */
    // Modes d'ouverture
    const CREATE;            // Crée l'archive si celle-ci n'existe pas
    const EXCL;              // Echoue si l'archive existe déjà
    const CHECKCONS;         // Effectue des contrôles supplémentaires
    const OVERWRITE;         // Remplace l'archive existante
    // Options
    const FL_NOCASE;         // La casse est ignorée sur l'entrée du nom
    const FL_NODIR;          // La partie répertoire est ignorée
    const FL_COMPRESSED;     // Lit les données compressées
    const FL_UNCHANGED;      // Utilise les données originales de l'archive (ignore les changements)
    // Modes de compression
    const CM_DEFAULT;        // Compression par défaut (offre le meilleur taux)
    const CM_STORE;          // Stockage uniquement (sans compression)
    const CM_SHRINK;         // Une variante de l'algorithme LZW
    const CM_REDUCE_1;       // Taux de compression réduit (niveau 1)
    const CM_REDUCE_2;       // Taux de compression réduit (niveau 2)
    const CM_REDUCE_3;       // Taux de compression réduit (niveau 3)
    const CM_REDUCE_4;       // Taux de compression réduit (niveau 4)
    const CM_IMPLODE;        // Réunit les séquences identiques avant compression
    const CM_DEFLATE;        // Utilisation de l'algorithme Deflate (RFC 1951)
    const CM_DEFLATE64;      // Variante de l'algorithme Deflate travaillant sur des blocs de 64 ko au lieu de 32
    const CM_PKWARE_IMPLODE; // Méthode officielle
    const CM_BZIP2;          // Compression utilisant l'algorithme bzip2
    // Erreurs
    const ER_OK;             // Aucune erreur
    const ER_MULTIDISK;      // Archives multi-disques non supportée
    const ER_RENAME;         // Erreur lors de la modification du nom du fichier temporaire
    const ER_CLOSE;          // Erreur lors de la fermeture de l'archive
    const ER_SEEK;           // Erreur de déplacement
    const ER_READ;           // Erreur de lecture
    const ER_WRITE;          // Erreur d'écriture
    const ER_CRC;            // Erreur dans la somme CRC
    const ER_ZIPCLOSED;      // L'archive ZIP est fermée
    const ER_NOENT;          // Fichier inexistant
    const ER_EXISTS;         // Le fichier est déjà présent
    const ER_OPEN;           // Ne peut ouvrir le fichier
    const ER_TMPOPEN;        // Erreur lors de la création du fichier temporaire
    const ER_ZLIB;           // Erreur interne liée à la librairie Zlib
    const ER_MEMORY;         // Erreur d'allocation dynamique de mémoire
    const ER_CHANGED;        // L'entrée a été modifiée
    const ER_COMPNOTSUPP;    // Méthode de compression non supportée
    const ER_EOF;            // Fin de fichier rencontrée prématurément
    const ER_INVAL;          // Argument invalide
    const ER_NOZIP;          // Ne s'agit pas d'une archive au format ZIP
    const ER_INTERNAL;       // Erreur interne
    const ER_INCONS;         // Archive inconsistante
    const ER_REMOVE;         // Ne peut supprimer un fichier
    const ER_DELETED;        // Entrée supprimée

    /* Propriétés */
    public $status;          // Numéro de l'erreur de la librairie libzip
    public $statusSys;       // Numéro de l'erreur système (errno) ou de la librairie zlib
    public $numFiles;        // Nombre de fichiers dans l'archive
    public $filename;        // Nom et chemin de l'archive
    public $comment;         // Commentaire associé à l'archive

    /* Méthodes */
    /**
     * Ouvrir une archive en vue de sa création ou manipulation
     * @param fichier  : le nom de l'archive à créer ou manipuler
     * @param drapeaux : mode d'ouverture de l'archive (CREATE, EXCL, CHECKCONS ou OVERWRITE)
     * @return TRUE ou un code décrivant l'erreur (constantes de classe commençant par ER_)
     **/
    public function open(chaîne fichier [, entier drapeaux]);

    /**
     * Fermer l'archive
     * @return un booléen, TRUE en cas de succès sinon FALSE
     **/
    public function close();

    /**
     * Ajouter un répertoire vide à l'archive
     * @param répertoire : le nom du répertoire à ajouter
     * @return un booléen, FALSE en cas d'échec et TRUE dans le cas contraire
     **/
    public function addEmptyDir(chaîne répertoire);

    /**
     * Ajouter un fichier virtuel (ie qui n'a pas d'existence physique) à l'archive
     * @param nom_local : nom sous lequel figurera le fichier au sein de l'archive
     * @param contenu   : le contenu de ce fichier
     * @return un booléen, FALSE si une erreur survient et TRUE si tout se passe normalement
     **/
    public function addFromString(chaîne nom_local, chaîne contenu);

    /**
     * Ajouter un fichier (physique) à l'archive
     * @param fichier   : le chemin complet vers le fichier à ajouter
     * @param nom_local : son nom dans l'archive s'il doit être différent
     * @param début     : position dans le fichier source à partir de laquelle son contenu doit être inséré
     * @param longueur  : nombre de caractères maximal à inclure
     * @return un booléen, FALSE en cas d'erreur et TRUE si tout va bien
     **/
    public function addFile(chaîne fichier [, chaîne nom_local [, entier début [, entier longueur]]]);

    /**
     * Renommer le fichier indiqué à partir de son indice
     * @param indice      : indice du fichier au sein de l'archive (compris entre 0 et $this->numFiles - 1 inclus)
     * @param nouveau_nom : le nouveau nom à donner à ce fichier
     * @return un booléen, TRUE si aucune erreur n'est survenue et FALSE dans le cas contraire
     **/
    public function renameIndex(entier indice, chaîne nouveau_nom);

    /**
     * Renommer le fichier indiqué à partir de son nom courant
     * @param nom         : nom actuel du fichier à renommer
     * @param nouveau_nom : son nouveau nom
     * @return un booléen, TRUE si aucune erreur ne s'est produite sinon FALSE
     **/
    public function renameName(chaîne nom, nouveau_nom);

    /**
     * Change le commentaire actuel de l'archive
     * @param commentaire : le nouveau commentaire à attribuer à l'archive
     * @return un booléen, FALSE en cas d'échec ou bien TRUE si l'opération réussie
     **/
    public function setArchiveComment(chaîne commentaire);

    /**
     * Renvoie le commentaire actuel de l'archive
     * @return ce commentaire sous la forme d'une chaîne de caractères
     **/
    public function getArchiveComment();

    /**
     * Changer le commentaire associé à une entrée de l'archive à partir de son indice
     * @param indice      : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @param commentaire : le nouveau commentaire attribué au fichier
     * @return un booléen, FALSE en cas d'erreur sinon TRUE
     **/
    public function setCommentIndex(entier indice, chaîne commentaire);

    /**
     * Changer le commentaire d'une entrée de l'archive à l'aide de son nom
     * @param nom         : nom actuel du fichier dans l'archive
     * @param commentaire : le nouveau commentaire à associer à ce fichier
     * @return un booléen, FALSE si l'opération échoue et TRUE dans le cas contraire
     **/
    public function setCommentName(chaîne nom, chaîne commentaire);

    /**
     * Obtenir le commentaire correspondant à une entrée par son indice
     * @param indice   : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE en cas d'erreur ou une chaîne correspondant au commentaire (éventuellement vide s'il n'y a
     *         aucun commentaire)
     **/
    public function getCommentIndex(entier indice [, entier drapeaux]);

    /**
     * Obtenir le commentaire associé à un fichier à l'aide du nom de celle-ci
     * @param nom      : nom de l'entrée cible
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE en cas d'erreur ou une chaîne correspondant au commentaire (éventuellement vide s'il n'y a
     *         aucun commentaire)
     **/
    public function getCommentName(chaîne nom [, entier drapeaux]);

    /**
     * Supprimer une entrée de l'archive à partir de son indice
     * @param indice : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @return un booléen, TRUE si la suppression a pu être effectuée sinon FALSE
     **/
    public function deleteIndex(entier indice);

    /**
     * Supprimer un fichier de l'archive à l'aide de son nom
     * @param nom : nom de l'entrée à supprimer
     * @return un booléen, FALSE si la suppression a échoué et TRUE dans le cas contraire
     **/
    public function deleteName(chaîne nom);

    /**
     * Obtenir les informations relatives à une entrée à l'aide de son nom
     * @param nom      : le nom de l'entrée visée
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE en cas d'échec ou bien un tableau associatif de la forme :
     *         Array (
     *                   'name' => nom du fichier
     *                   'index' => indice de l'entrée au sein de l'archive
     *                   'crc' => sa somme de contrôle
     *                   'size' => taille du fichier non compressé
     *                   'mtime' => timestamp représentant la date de dernière modification du fichier
     *                   'comp_size' => taille du fichier compressé
     *                   'comp_method' => méthode de compression employée (voir les constantes de classe CM_)
     *         )
     **/
    public function statName(chaîne nom [, entier drapeaux]);

    /**
     * Obtenir les informations relatives à une entrée par son indice
     * @param indice : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE en cas d'échec ou bien un tableau associatif de la forme :
     *         Array (
     *                   'name' => nom du fichier
     *                   'index' => indice de l'entrée au sein de l'archive
     *                   'crc' => sa somme de contrôle
     *                   'size' => taille du fichier non compressé
     *                   'mtime' => timestamp représentant la date de dernière modification du fichier
     *                   'comp_size' => taille du fichier compressé
     *                   'comp_method' => méthode de compression employée (voir les constantes de classe CM_)
     *         )
     **/
     **/
    public function statIndex(entier indice [, entier drapeaux]);

    /**
     * Obtenir l'indice d'une entrée particulière dans l'archive
     * @param nom      : le nom de cette entrée
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE si une erreur est survenue ou alors l'indice de l'entrée dans l'archive
     **/
    public function locateName(chaîne nom [, entier drapeaux]);

    /**
     * Obtenir le nom d'une entrée à partir de son indice
     * @param indice : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE en cas d'erreur et l'indice du fichier dans le cas contraire
     **/
    public function getNameIndex(entier indice [, entier drapeaux]);

    /**
     * Annule les modifications apportées sur l'archive (son commentaire uniquement)
     * @return un booléen, TRUE si les modifications ont pu être abrogées et FALSE si l'opération a échoué
     **/
    public function unchangeArchive();

    /**
     * Annuler l'ensemble des modifications apportées à l'archive (ceci inclut son contenu)
     * @return un booléen, FALSE en cas d'impossibilité de revenir à l'état original de l'archive sinon TRUE
     **/
    public function unchangeAll();

    /**
     * Annuler toutes les modifications apportées au fichier désigné par son indice
     * @param indice : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @return un booléen, TRUE si l'annulation a pu être rendue effective et FALSE dans le cas contraire
     **/
    public function unchangeIndex(entier indice);

    /**
     * Annuler toutes les modifications apportées sur l'entrée indiquée par son nom
     * @param nom : nom du fichier concerné par cette annulation
     * @return un booléen, TRUE si l'opération a pu être menée à bien et FALSE en cas d'erreur
     **/
    public function unchangeName(chaîne nom);

    /**
     * Extraire une archive, partiellement ou non
     * @param destination : emplacement sur le système de fichiers où l'extraction aura lieu
     * @param entrées     : noms des seules entrées à extraire. S'il y en a qu'une il est possible d'utiliser
     *                      une chaîne de caractères plutôt qu'un tableau
     * @return un booléen, TRUE pour le bon déroulement de l'opération et FALSE si une erreur est survenue
     **/
    public function extractTo(chaîne destination [, variable entrées]);

    /**
     * Récupérer le contenu d'une entrée à partir de son nom
     * @param nom      : nom de l'entrée dont on souhaite obtenir son contenu
     * @param longueur : spécifie le nombre de caractères maximal à renvoyer (une valeur < 1 a pour effet de
     *                   rendre cette fonctionnalité inopérante)
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE si une erreur est survenue ou alors le contenu du fichier
     **/
    public function getFromName(chaîne nom [, entier longueur [, entier drapeaux]]);

    /**
     * Récupérer le contenu d'une entrée à l'aide de son indice
     * @param indice   : indice du fichier concerné (compris entre 0 et $this->numFiles - 1 inclus)
     * @param longueur : spécifie le nombre de caractères maximal attendu (une valeur < 1 a pour effet de
     *                   rendre cette fonctionnalité inopérante)
     * @param drapeaux : une des options (constantes de classe débutant par FL_)
     * @return FALSE en cas d'échec sinon le contenu du fichier sous la forme d'une chaîne de caractères
     **/
    public function getFromIndex(entier indice [, entier longueur [, entier drapeaux]]);

    /**
     * Obtenir un descripteur de fichier sur une entrée de l'archive
     * @param nom : nom de l'entrée
     * @return FALSE en cas d'erreur ou alors une ressource
     **/
    public function getStream(chaîne nom);
}

$zip = new ZipArchive();

if ($zip->open("nom_de_l'archive", "optionnel : mode de création") !== TRUE)) {
    die("Impossible d'ouvrir l'archive demandée");
}

$zip->close();

function creer_archive($nom, $fichiers, $commentaire = '')
{
    if (is_array($fichiers)) {
        $zip = new ZipArchive();
        if ($zip->open($nom, ZIPARCHIVE::OVERWRITE) !== TRUE) {
            return FALSE;
        }
        foreach ($fichiers as $k => $f) {
            if (!$zip->addFile($f)) {
                return FALSE;
            }
            if (is_string($k)) {
                $zip->setCommentName($f, $k);
            }
        }
        if ($commentaire) {
            $zip->setArchiveComment($commentaire);
        }
        return $zip->close();
    }
    return FALSE;
}

# Parcours du répertoire courant à la recherche des fichiers php qui constitueront la liste des fichiers à zipper
$repertoire = '.';
$fichiers = array();
$dir = opendir($repertoire);
while (($file = readdir($dir)) !== FALSE) {
    if ($file == '.' or $file == '..') {
        continue;
    }
    if (preg_match('/\.php[45]?$/', $file)) {
        $fichiers[] = $file;
    }
}
closedir($dir);

creer_archive('sources.zip', $fichiers, "Les sources du tutoriel portant sur l'extension ZIP")
    or die("Echec lors de la création de l'archive");

function zip_recursif($chemin, $zip, $prefixe = '')
{
    if (substr($chemin, -1, 1) != DIRECTORY_SEPARATOR) {
        $chemin .= DIRECTORY_SEPARATOR;
    }
    if (file_exists($chemin)) {
        if (is_dir($chemin)) {
            if (!($dh = opendir($chemin))) {
                return FALSE;
            }
            while (($fichier = readdir($dh)) !== FALSE) {
                if ($fichier == '.' || $fichier == '..') {
                    continue;
                }
                if (is_dir($chemin . $fichier)) {
                    $zip->addEmptyDir($prefixe . $fichier);
                    if (!zip_recursif($chemin . $fichier . DIRECTORY_SEPARATOR, $zip, $prefixe . $fichier . DIRECTORY_SEPARATOR)) {
                        return FALSE;
                    }
                } else {
                    if (!$zip->addFile($chemin . $fichier, $prefixe . $fichier)) {
                        return FALSE;
                    }
                }
            }
            closedir($dh);
            return TRUE;
        } else {
            if (!$zip->addFile($chemin)) {
                return FALSE;
            }
            return TRUE;
        }
    }
    return FALSE;
}

# Exemple d'utilisation
$zip = new ZipArchive();
if ($zip->open('sources.zip', ZipArchive::OVERWRITE) !== TRUE) {
    die("Impossible de créer l'archive");
}
zip_recursif('/home/julp/www/zip', $zip);
$zip->close();

class MyZip extends ZipArchive
{
    public function __construct($nom, $commentaire = '')
    {
        if ($this->open($nom, ZIPARCHIVE::OVERWRITE) !== TRUE) {
            throw new Exception("L'archive ne peut être créée");
        }

        if ($commentaire) {
            $this->setArchiveComment($commentaire);
        }
    }

    public function __destruct()
    {
        $this->close();
    }

    public function addFiles(Array $fichiers)
    {
        foreach ($fichiers as $k => $f) {
            if (!$this->addFile($f)) {
                throw new Exception("Le fichier '$f' n'a pu être ajouté à l'archive");
            }

            if (is_string($k)) {
                $this->setCommentName($f, $k);
            }
        }
    }

    public function addRecursive($chemin, $prefixe = '')
    {
        $chemin = realpath($chemin) . DIRECTORY_SEPARATOR;

        if (!file_exists($chemin)) {
            throw new Exception("Le chemin '$chemin' n'existe pas");
        }

        if (!is_dir($chemin)) {
            throw new Exception("Le chemin '$chemin' existe mais n'est pas un répertoire");
        }

        if (!($dh = opendir($chemin))) {
            throw new Exception("Le répertoire '$chemin' n'est pas accessible");
        }

        while (($fichier = readdir($dh)) !== FALSE) {
            if ($fichier == '.' || $fichier == '..') {
                continue;
            }
            if (is_dir($chemin . $fichier)) {
                $this->addEmptyDir($prefixe . $fichier);
                $this->addRecursive($chemin . $fichier . DIRECTORY_SEPARATOR, $prefixe . $fichier . DIRECTORY_SEPARATOR);
            } else {
                if (!$this->addFile($chemin . $fichier, $prefixe . $fichier)) {
                    throw new Exception("Le fichier '$chemin/$fichier' n'a pu être ajouté à l'archive");
                }
            }
        }
        closedir($dh);
    }
}

require_once('/var/www/offline/librairies/MyZip.php');

$repertoire = '.';
$fichiers = array();
$dir = opendir($repertoire);
while (($file = readdir($dir)) !== FALSE) {
    if ($file == '.' or $file == '..') {
        continue;
    }
    if (preg_match('/\.php[45]?$/', $file)) {
        $fichiers[] = $file;
    }
}
closedir($dir);

try {
    $sources = new MyZip('sources.zip', "Les sources du tutoriel portant sur l'extension ZIP");
    $sources->addFiles($fichiers);
    $sources->addRecursive('/home/julp/www/zip');
} catch (Exception $e) {
    die("Echec lors de la création de l'archive : " . $e->getMessage());
}

$zip = new ZipArchive();
if ($zip->open('sources.zip') !== TRUE) {
    die("Echec lors de l'ouverture de l'archive");
}
$zip->addFromString('README', "Le tutoriel associé se trouve à l'adresse suivante : http://julp.developpez.com/php/zip/")
    or die("Impossible de rajouter un fichier à l'archive");
$zip->close() or die("Erreur lors de la fermeture de l'archive");

$zip = new ZipArchive();
if ($zip->open('sources.zip') !== TRUE) {
    die("Echec lors de l'ouverture de l'archive");
}
$zip->deleteName('README') or die("Cette entrée n'a pu être supprimé");
$zip->close() or die("Erreur lors de la fermeture de l'archive");