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