Inicio>código fuente PHP>Otras categorias
Descargar

PhpZip es una biblioteca php para trabajo extendido con archivos ZIP.

Documentación rusa

Versiones y dependencias

Versión PHP Documentación
^4.0 (maestro) ^7.4|^8.0 actual
^3.0 ^5.5|^7.0 Documentos v3.3

Tabla de contenido

  • Características
  • Requisitos
  • Instalación
  • Ejemplos
  • Glosario
  • Documentación
    • Descripción general de los métodos de la clase PhpZipZipFile
    • Creación/Apertura de archivo ZIP
    • Leer entradas del archivo
    • Entradas iterantes
    • Obtener información sobre las entradas
    • Agregar entradas al archivo
    • Eliminar entradas del archivo
    • Trabajar con entradas y archivos
    • Trabajar con contraseñas
    • Deshacer cambios
    • Guardar un archivo o salida en un navegador
    • Cerrando el archivo
  • ejecutando las pruebas
  • Registro de cambios
  • Mejora
    • Actualice la versión 3 a la versión 4
    • Actualizar la versión 2 a la versión 3

Características

  • Abrir y descomprimir archivos zip.
  • Creación de archivos ZIP.
  • Modificación de archivos ZIP.
  • PHP puro (no requiere extensión php-zip y clase ZipArchive ).
  • Admite guardar el archivo en un archivo, enviar el archivo al navegador o generarlo como una cadena sin guardarlo en un archivo.
  • Se admiten comentarios de archivo y comentarios de entrada individual.
  • Obtenga información sobre cada entrada del archivo.
  • Solo se admiten los siguientes métodos de compresión:
    • No comprimido (Almacenado).
    • Compresión desinflada.
    • Compresión BZIP2 con la extensión php-bz2 .
  • Soporte para ZIP64 (el tamaño del archivo es superior a 4 GB o el número de entradas en el archivo es superior a 65535).
  • Trabajar con contraseñas

    ¡Atención!

    Para sistemas de 32 bits, el método de cifrado Traditional PKWARE Encryption (ZipCrypto) no es compatible actualmente. Utilice el método de cifrado WinZIP AES Encryption , siempre que sea posible.

    • Establezca la contraseña para leer el archivo de todas las entradas o solo de algunas.
    • Cambie la contraseña del archivo, incluso para entradas individuales.
    • Elimine la contraseña de archivo para todas o las entradas individuales.
    • Establezca la contraseña y/o el método de cifrado, tanto para todas como para las entradas individuales del archivo.
    • Establezca diferentes contraseñas y métodos de cifrado para diferentes entradas.
    • Elimine la contraseña de todas o algunas entradas.
    • Admite los métodos de cifrado de cifrado Traditional PKWARE Encryption (ZipCrypto) y WinZIP AES Encryption .
    • Establezca el método de cifrado para todas o las entradas individuales del archivo.

Requisitos

  • PHP >= 7.4 o PHP >= 8.0 (preferiblemente 64 bits).
  • Extensión php bzip2 opcional para compresión BZIP2.
  • Extensión PHP openssl opcional para compatibilidad con WinZip Aes Encryption .

Instalación

composer require nelexa/zip

Última versión estable:

Ejemplos 

 // create new archive
$ zipFile = new  PhpZip  ZipFile ();
try {
    $ zipFile
        -> addFromString ( ' zip/entry/filename ' , ' Is file content ' ) // add an entry from the string
        -> addFile ( ' /path/to/file ' , ' data/tofile ' ) // add an entry from the file
        -> addDir ( __DIR__ , ' to/path/ ' ) // add files from the directory
        -> saveAsFile ( $ outputFilename ) // save the archive to a file
        -> close (); // close archive
            
    // open archive, extract, add files, set password and output to browser.
    $ zipFile
        -> openFile ( $ outputFilename ) // open archive from file
        -> extractTo ( $ outputDirExtract ) // extract files to the specified directory
        -> deleteFromRegex ( ' ~^.~ ' ) // delete all hidden (Unix) files
        -> addFromString ( ' dir/file.txt ' , ' Test file ' ) // add a new entry from the string
        -> setPassword ( ' password ' ) // set password for all entries
        -> outputAsAttachment ( ' library.jar ' ); // output to the browser without saving to a file
}
catch (  PhpZip  Exception  ZipException $ e ){
    // handle exception
}
finally {
    $ zipFile -> close ();
}

Otros ejemplos se pueden encontrar en la carpeta tests/

Glosario

Entrada Zip : archivo o carpeta en un archivo ZIP. Cada entrada en el archivo tiene ciertas propiedades, por ejemplo: nombre del archivo, método de compresión, método de cifrado, tamaño del archivo antes de la compresión, tamaño del archivo después de la compresión, CRC32 y otras.

Documentación:

Descripción general de los métodos de la clase PhpZipZipFile

  • ZipFile::__construct: inicializa el archivo ZIP.
  • ZipFile::addAll: agrega todas las entradas de una matriz.
  • ZipFile::addDir: agrega archivos al archivo desde el directorio en la ruta especificada sin subdirectorios.
  • ZipFile::addDirRecursive: agrega archivos al archivo desde el directorio en la ruta especificada con subdirectorios.
  • ZipFile::addEmptyDir: agrega un nuevo directorio.
  • ZipFile::addFile: agrega un archivo a un archivo ZIP desde la ruta indicada.
  • ZipFile::addSplFile: agrega un SplFileInfo a un archivo ZIP.
  • ZipFile::addFromFinder: agrega archivos de SymfonyComponentFinderFinder a un archivo ZIP.
  • ZipFile::addFilesFromIterator: agrega archivos del iterador de directorios.
  • ZipFile::addFilesFromGlob: agrega archivos de un directorio mediante un patrón global sin subdirectorios.
  • ZipFile::addFilesFromGlobRecursive: agrega archivos de un directorio mediante un patrón global con subdirectorios.
  • ZipFile::addFilesFromRegex: agrega archivos de un directorio según el patrón PCRE sin subdirectorios.
  • ZipFile::addFilesFromRegexRecursive: agrega archivos de un directorio mediante el patrón PCRE con subdirectorios.
  • ZipFile::addFromStream: agrega una entrada de la secuencia al archivo ZIP.
  • ZipFile::addFromString: agrega un archivo a un archivo ZIP utilizando su contenido.
  • ZipFile::close: cierra el archivo.
  • ZipFile::count: devuelve el número de entradas en el archivo.
  • ZipFile::deleteFromName: elimina una entrada en el archivo usando su nombre.
  • ZipFile::deleteFromGlob: elimina entradas en el archivo usando el patrón global.
  • ZipFile::deleteFromRegex: elimina entradas en el archivo usando el patrón PCRE.
  • ZipFile::deleteAll: elimina todas las entradas del archivo ZIP.
  • ZipFile::disableEncryption: deshabilita el cifrado para todas las entradas que ya están en el archivo.
  • ZipFile::disableEncryptionEntry: desactiva el cifrado de una entrada definida por su nombre.
  • ZipFile::extractTo: extrae el contenido del archivo comprimido.
  • ZipFile::getArchiveComment: devuelve el comentario del archivo Zip.
  • ZipFile::getEntryComment: devuelve el comentario de una entrada utilizando el nombre de la entrada.
  • ZipFile::getEntryContent: devuelve el contenido de la entrada utilizando su nombre.
  • ZipFile::getListFiles: devuelve una lista de archivos comprimidos.
  • ZipFile::hasEntry: comprueba si hay una entrada en el archivo.
  • ZipFile::isDirectory: comprueba que la entrada en el archivo sea un directorio.
  • ZipFile::matcher: selecciona entradas en el archivo para realizar operaciones en ellas.
  • ZipFile::openFile: abre un archivo zip desde un archivo.
  • ZipFile::openFromString: abre un archivo zip desde una cadena.
  • ZipFile::openFromStream: abre un archivo zip de la secuencia.
  • ZipFile::outputAsAttachment: genera un archivo ZIP en el navegador.
  • ZipFile::outputAsPsr7Response: genera un archivo ZIP como respuesta PSR-7.
  • ZipFile::outputAsSymfonyResponse: genera un archivo ZIP como Symfony Response.
  • ZipFile::outputAsString: genera un archivo ZIP como una cadena.
  • ZipFile::rename: cambia el nombre de una entrada definida por su nombre.
  • ZipFile::rewrite: guarda los cambios y vuelve a abrir el archivo modificado.
  • ZipFile::saveAsFile: guarda el archivo en un archivo.
  • ZipFile::saveAsStream: escribe el archivo en la secuencia.
  • ZipFile::setArchiveComment: establece el comentario de un archivo ZIP.
  • ZipFile::setCompressionLevel: establece el nivel de compresión para todos los archivos del archivo.
  • ZipFile::setCompressionLevelEntry: establece el nivel de compresión de la entrada por su nombre.
  • ZipFile::setCompressionMethodEntry: establece el método de compresión para la entrada por su nombre.
  • ZipFile::setEntryComment: establece el comentario de una entrada definida por su nombre.
  • ZipFile::setReadPassword: establece la contraseña para el archivo abierto.
  • ZipFile::setReadPasswordEntry: establece una contraseña para leer una entrada definida por su nombre.
  • ZipFile::setPassword: establece una nueva contraseña para todos los archivos del archivo.
  • ZipFile::setPasswordEntry: establece una nueva contraseña para una entrada definida por su nombre.
  • ZipFile::unchangeAll: deshace todos los cambios realizados en el archivo.
  • ZipFile::unchangeArchiveComment: deshace los cambios en el comentario del archivo.
  • ZipFile::unchangeEntry: deshace los cambios de una entrada definida por su nombre.

Creación/Apertura de archivo ZIP

Archivo Zip::__construcción**

Inicializa el archivo ZIP 

 $ zipFile = new  PhpZip  ZipFile ();
Archivo Zip::abrirArchivo

Abre un archivo zip desde un archivo. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> openFile ( ' file.zip ' );
Archivo Zip::openFromString

Abre un archivo zip desde una cadena. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> openFromString ( $ stringContents );
Archivo Zip::openFromStream

Abre un archivo zip de la secuencia. 

 $ stream = fopen ( ' file.zip ' , ' rb ' );

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> openFromStream ( $ stream );

Leer entradas del archivo

Archivo Zip::recuento

Devuelve el número de entradas en el archivo. 

 $ zipFile = new  PhpZip  ZipFile ();

$ count = count ( $ zipFile );
// or
$ count = $ zipFile -> count ();
Archivo Zip::getListFiles

Devuelve una lista de archivos comprimidos. 

 $ zipFile = new  PhpZip  ZipFile ();
$ listFiles = $ zipFile -> getListFiles ();

// example array contents:
// array (
//   0 => 'info.txt',
//   1 => 'path/to/file.jpg',
//   2 => 'another path/',
//   3 => '0',
// )
Archivo Zip::getEntryContent

Devuelve el contenido de la entrada usando su nombre. 

 // $entryName = 'path/to/example-entry-name.txt';
$ zipFile = new  PhpZip  ZipFile ();

$ contents = $ zipFile [ $ entryName ];
// or
$ contents = $ zipFile -> getEntryContents ( $ entryName );
Archivo Zip::haEntry

Comprueba si hay una entrada en el archivo. 

 // $entryName = 'path/to/example-entry-name.txt';
$ zipFile = new  PhpZip  ZipFile ();

$ hasEntry = isset ( $ zipFile [ $ entryName ]);
// or
$ hasEntry = $ zipFile -> hasEntry ( $ entryName );
Archivo Zip::esDirectorio

Comprueba que la entrada en el archivo es un directorio. 

 // $entryName = 'path/to/';
$ zipFile = new  PhpZip  ZipFile ();

$ isDirectory = $ zipFile -> isDirectory ( $ entryName );
Archivo Zip::extraerA

Extraiga el contenido del archivo. El directorio debe existir. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> extractTo ( $ directory );

Extraiga algunos archivos al directorio. El directorio debe existir. 

 // $toDirectory = '/tmp';
$ extractOnlyFiles = [
    ' filename1 ' , 
    ' filename2 ' , 
    ' dir/dir/dir/ '
];
$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> extractTo ( $ toDirectory , $ extractOnlyFiles );

Entradas iterantes

ZipFile es un iterador. Puede iterar todas las entradas en el bucle foreach . 

 foreach ( $ zipFile as $ entryName => $ contents ){
    echo " Filename: $ entryName " . PHP_EOL ;
    echo " Contents: $ contents " . PHP_EOL ;
    echo ' ----------------------------- ' . PHP_EOL ;
}

Puede iterar a través del Iterator . 

 $ iterator = new  ArrayIterator ( $ zipFile );
while ( $ iterator -> valid ())
{
    $ entryName = $ iterator -> key ();
    $ contents = $ iterator -> current ();

    echo " Filename: $ entryName " . PHP_EOL ;
    echo " Contents: $ contents " . PHP_EOL ;
    echo ' ----------------------------- ' . PHP_EOL ;

    $ iterator -> next ();
}

Obtener información sobre las entradas

Archivo Zip::getArchiveComentario

Devuelve el comentario del archivo Zip. 

 $ zipFile = new  PhpZip  ZipFile ();
$ commentArchive = $ zipFile -> getArchiveComment ();
Archivo Zip::getEntryComment

Devuelve el comentario de una entrada utilizando el nombre de la entrada. 

 $ zipFile = new  PhpZip  ZipFile ();
$ commentEntry = $ zipFile -> getEntryComment ( $ entryName );

Agregar entradas al archivo

Todos los métodos para agregar entradas a un archivo ZIP le permiten especificar un método para comprimir contenido.

Están disponibles los siguientes métodos de compresión:

  • PhpZipConstantsZipCompressionMethod::STORED - sin compresión
  • PhpZipConstantsZipCompressionMethod::DEFLATED - Desinflar compresión
  • PhpZipConstantsZipCompressionMethod::BZIP2 - Compresión Bzip2 con la extensión ext-bz2
Archivo Zip::añadir archivo

Agrega un archivo a un archivo ZIP desde la ruta indicada. 

 $ zipFile = new  PhpZip  ZipFile ();
// $file = '...../file.ext'; 
// $entryName = 'file2.ext'
$ zipFile -> addFile ( $ file );

// you can specify the name of the entry in the archive (if null, then the last component from the file name is used)
$ zipFile -> addFile ( $ file , $ entryName );

// you can specify a compression method
$ zipFile -> addFile ( $ file , $ entryName ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFile ( $ file , $ entryName ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFile ( $ file , $ entryName ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
Archivo Zip::añadir archivo Spl

Agrega un SplFileInfo a un archivo ZIP. 

 // $file = '...../file.ext'; 
// $entryName = 'file2.ext'
$ zipFile = new  PhpZip  ZipFile ();

$ splFile = new  SplFileInfo ( ' README.md ' );

$ zipFile -> addSplFile ( $ splFile );
$ zipFile -> addSplFile ( $ splFile , $ entryName );
// or
$ zipFile [ $ entryName ] = new  SplFileInfo ( $ file );

// set compression method
$ zipFile -> addSplFile ( $ splFile , $ entryName , $ options = [
     PhpZip  Constants ZipOptions:: COMPRESSION_METHOD =>  PhpZip  Constants ZipCompressionMethod:: DEFLATED ,
]);
Archivo Zip::addFromFinder

Agrega archivos de SymfonyComponentFinderFinder a un archivo ZIP. 

 $ finder = new  Symfony  Component  Finder  Finder ();
$ finder
    -> files ()
    -> name ( ' *.{jpg,jpeg,gif,png} ' )
    -> name ( ' /^[0-9a-f]./ ' )
    -> contains ( ' /lorems+ipsum$/i ' )
    -> in ( ' path ' );

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addFromFinder ( $ finder , $ options = [
     PhpZip  Constants ZipOptions:: COMPRESSION_METHOD =>  PhpZip  Constants ZipCompressionMethod:: DEFLATED ,
     PhpZip  Constants ZipOptions:: MODIFIED_TIME => new  DateTimeImmutable ( ' -1 day 5 min ' )
]);
Archivo Zip::addFromString

Agrega un archivo a un archivo ZIP usando su contenido. 

 $ zipFile = new  PhpZip  ZipFile ();

$ zipFile [ $ entryName ] = $ contents ;
// or
$ zipFile -> addFromString ( $ entryName , $ contents );

// you can specify a compression method
$ zipFile -> addFromString ( $ entryName , $ contents ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFromString ( $ entryName , $ contents ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFromString ( $ entryName , $ contents ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
Archivo Zip::addFromStream

Agrega una entrada de la transmisión al archivo ZIP. 

 $ zipFile = new  PhpZip  ZipFile ();
// $stream = fopen(..., 'rb');

$ zipFile -> addFromStream ( $ stream , $ entryName );
// or
$ zipFile [ $ entryName ] = $ stream ;

// you can specify a compression method
$ zipFile -> addFromStream ( $ stream , $ entryName ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFromStream ( $ stream , $ entryName ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFromStream ( $ stream , $ entryName ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
Archivo Zip::añadirDirVacío

Agregue un nuevo directorio. 

 $ zipFile = new  PhpZip  ZipFile ();
// $path = "path/to/";
$ zipFile -> addEmptyDir ( $ path );
// or
$ zipFile [ $ path ] = null ;
Archivo Zip::añadir todo

Agrega todas las entradas de una matriz. 

 $ entries = [
    ' file.txt ' => ' file contents ' , // add an entry from the string contents
    ' empty dir/ ' => null , // add empty directory
    ' path/to/file.jpg ' => fopen ( ' ..../filename ' , ' rb ' ), // add an entry from the stream
    ' path/to/file.dat ' => new  SplFileInfo ( ' ..../filename ' ), // add an entry from the file
];

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addAll ( $ entries );
Archivo Zip::añadirDir

Agrega archivos al archivo desde el directorio en la ruta especificada sin subdirectorios. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addDir ( $ dirName );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addDir ( $ dirName , $ localPath );

// you can specify a compression method
$ zipFile -> addDir ( $ dirName , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addDir ( $ dirName , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addDir ( $ dirName , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
Archivo Zip::addDirRecursive

Agrega archivos al archivo desde el directorio en la ruta especificada con subdirectorios. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addDirRecursive ( $ dirName );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addDirRecursive ( $ dirName , $ localPath );

// you can specify a compression method
$ zipFile -> addDirRecursive ( $ dirName , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addDirRecursive ( $ dirName , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addDirRecursive ( $ dirName , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
ZipFile::añadirFilesFromIterator

Agrega archivos del iterador de directorios. 

 // $directoryIterator = new DirectoryIterator($dir); // without subdirectories
// $directoryIterator = new RecursiveDirectoryIterator($dir); // with subdirectories
$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addFilesFromIterator ( $ directoryIterator );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addFilesFromIterator ( $ directoryIterator , $ localPath );
// or
$ zipFile [ $ localPath ] = $ directoryIterator ;

// you can specify a compression method
$ zipFile -> addFilesFromIterator ( $ directoryIterator , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFilesFromIterator ( $ directoryIterator , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFilesFromIterator ( $ directoryIterator , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression

Ejemplo con algunos archivos ignorando: 

 $ ignoreFiles = [
    ' file_ignore.txt ' , 
    ' dir_ignore/sub dir ignore/ '
];

// $directoryIterator = new DirectoryIterator($dir); // without subdirectories
// $directoryIterator = new RecursiveDirectoryIterator($dir); // with subdirectories
// use PhpZipUtilIteratorIgnoreFilesFilterIterator for non-recursive search
 
$ zipFile = new  PhpZip  ZipFile ();
$ ignoreIterator = new  PhpZip  Util  Iterator  IgnoreFilesRecursiveFilterIterator (
    $ directoryIterator , 
    $ ignoreFiles
);

$ zipFile -> addFilesFromIterator ( $ ignoreIterator );
Archivo Zip::addFilesFromGlob

Agrega archivos de un directorio por patrón global sin subdirectorios. 

 $ globPattern = ' **.{jpg,jpeg,png,gif} ' ; // example glob pattern -> add all .jpg, .jpeg, .png and .gif files

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addFilesFromGlob ( $ dir , $ globPattern );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addFilesFromGlob ( $ dir , $ globPattern , $ localPath );

// you can specify a compression method
$ zipFile -> addFilesFromGlob ( $ dir , $ globPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFilesFromGlob ( $ dir , $ globPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFilesFromGlob ( $ dir , $ globPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
ZipFile::addFilesFromGlobRecursive

Agrega archivos de un directorio por patrón global con subdirectorios. 

 $ globPattern = ' **.{jpg,jpeg,png,gif} ' ; // example glob pattern -> add all .jpg, .jpeg, .png and .gif files

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addFilesFromGlobRecursive ( $ dir , $ globPattern );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addFilesFromGlobRecursive ( $ dir , $ globPattern , $ localPath );

// you can specify a compression method
$ zipFile -> addFilesFromGlobRecursive ( $ dir , $ globPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFilesFromGlobRecursive ( $ dir , $ globPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFilesFromGlobRecursive ( $ dir , $ globPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
Archivo Zip::añadirArchivosDeRegex

Agrega archivos de un directorio según el patrón PCRE sin subdirectorios. 

 $ regexPattern = ' /.(jpe?g|png|gif)$/si ' ; // example regex pattern -> add all .jpg, .jpeg, .png and .gif files

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> addFilesFromRegex ( $ dir , $ regexPattern );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addFilesFromRegex ( $ dir , $ regexPattern , $ localPath );

// you can specify a compression method
$ zipFile -> addFilesFromRegex ( $ dir , $ regexPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFilesFromRegex ( $ dir , $ regexPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFilesFromRegex ( $ dir , $ regexPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression
ZipFile::addFilesFromRegexRecursive

Agrega archivos de un directorio según el patrón PCRE con subdirectorios. 

 $ regexPattern = ' /.(jpe?g|png|gif)$/si ' ; // example regex pattern -> add all .jpg, .jpeg, .png and .gif files

$ zipFile -> addFilesFromRegexRecursive ( $ dir , $ regexPattern );

// you can specify the path in the archive to which you want to put entries
$ localPath = ' to/path/ ' ;
$ zipFile -> addFilesFromRegexRecursive ( $ dir , $ regexPattern , $ localPath );

// you can specify a compression method
$ zipFile -> addFilesFromRegexRecursive ( $ dir , $ regexPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: STORED ); // No compression
$ zipFile -> addFilesFromRegexRecursive ( $ dir , $ regexPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED ); // Deflate compression
$ zipFile -> addFilesFromRegexRecursive ( $ dir , $ regexPattern , $ localPath ,  PhpZip  Constants ZipCompressionMethod:: BZIP2 ); // BZIP2 compression

Eliminar entradas del archivo

Archivo Zip::eliminarDeNombre

Elimina una entrada en el archivo usando su nombre. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> deleteFromName ( $ entryName );
Archivo Zip::eliminarDeGlob

Elimina entradas en el archivo usando el patrón global. 

 $ globPattern = ' **.{jpg,jpeg,png,gif} ' ; // example glob pattern -> delete all .jpg, .jpeg, .png and .gif files

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> deleteFromGlob ( $ globPattern );
Archivo Zip::eliminarDeRegex

Elimina entradas en el archivo usando el patrón PCRE. 

 $ regexPattern = ' /.(jpe?g|png|gif)$/si ' ; // example regex pattern -> delete all .jpg, .jpeg, .png and .gif files

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> deleteFromRegex ( $ regexPattern );
Archivo Zip::eliminar todo

Elimina todas las entradas del archivo ZIP. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> deleteAll ();

Trabajar con entradas y archivos

Archivo Zip::cambiar nombre

Cambia el nombre de una entrada definida por su nombre. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> rename ( $ oldName , $ newName );
Archivo Zip::setCompressionLevel

Establezca el nivel de compresión para todos los archivos del archivo.

Tenga en cuenta que este método no se aplica a las entradas que se agregan después de ejecutar este método.

De forma predeterminada, el nivel de compresión es 5 ( PhpZipConstantsZipCompressionLevel::NORMAL ) o el nivel de compresión especificado en el archivo para la compresión Deflate.

Se admiten los valores que van desde 1 ( PhpZipConstantsZipCompressionLevel::SUPER_FAST ) a 9 ( PhpZipConstantsZipCompressionLevel::MAXIMUM ). Cuanto mayor sea el número, mejor y más larga será la compresión. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setCompressionLevel ( PhpZip  Constants ZipCompressionLevel:: MAXIMUM );
Archivo Zip::setCompressionLevelEntry

Establece el nivel de compresión de la entrada por su nombre.

Se admiten los valores que van desde 1 ( PhpZipConstantsZipCompressionLevel::SUPER_FAST ) a 9 ( PhpZipConstantsZipCompressionLevel::MAXIMUM ). Cuanto mayor sea el número, mejor y más larga será la compresión. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setCompressionLevelEntry ( $ entryName ,  PhpZip  Constants ZipCompressionLevel:: FAST );
Archivo Zip::setCompressionMethodEntry

Establece el método de compresión para la entrada por su nombre.

Están disponibles los siguientes métodos de compresión:

  • PhpZipConstantsZipCompressionMethod::STORED - Sin compresión
  • PhpZipConstantsZipCompressionMethod::DEFLATED - Desinflar compresión
  • PhpZipConstantsZipCompressionMethod::BZIP2 - Compresión Bzip2 con la extensión ext-bz2 
 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setCompressionMethodEntry ( $ entryName ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED );
Archivo Zip::setArchivoComentario

Establecer el comentario de un archivo ZIP. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setArchiveComment ( $ commentArchive );
Archivo Zip::setEntryComentario

Establece el comentario de una entrada definida por su nombre. 

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setEntryComment ( $ entryName , $ comment );
Archivo Zip::combinador

Seleccionar entradas en el archivo para realizar operaciones sobre ellas. 

 $ zipFile = new  PhpZip  ZipFile ();
$ matcher = $ zipFile -> matcher ();

Seleccionar archivos del archivo uno a la vez: 

 $ matcher
    -> add ( ' entry name ' )
    -> add ( ' another entry ' );

Seleccione varios archivos en el archivo: 

 $ matcher -> add ([
    ' entry name ' ,
    ' another entry name ' ,
    ' path/ '
]);

Seleccionar archivos por expresión regular: 

 $ matcher -> match ( ' ~.jpe?g$~i ' );

Seleccione todos los archivos en el archivo: 

 $ matcher -> all ();

count() - obtiene el número de entradas seleccionadas: 

 $ count = count ( $ matcher );
// or
$ count = $ matcher -> count ();

getMatches() - devuelve una lista de entradas seleccionadas: 

 $ entries = $ matcher -> getMatches ();
// example array contents: ['entry name', 'another entry name'];

invoke() - invoca una función invocable en entradas seleccionadas: 

 // example
$ matcher -> invoke ( static function ( $ entryName ) use ( $ zipFile ) {
    $ newName = preg_replace ( ' ~.(jpe?g)$~i ' , ' .no_optimize.$1 ' , $ entryName );
    $ zipFile -> rename ( $ entryName , $ newName );
});

Funciones para trabajar en las entradas seleccionadas: 

 $ matcher -> delete (); // remove selected entries from a ZIP archive
$ matcher -> setPassword ( $ password ); // sets a new password for the selected entries
$ matcher -> setPassword ( $ password , $ encryptionMethod ); // sets a new password and encryption method to selected entries
$ matcher -> setEncryptionMethod ( $ encryptionMethod ); // sets the encryption method to the selected entries
$ matcher -> disableEncryption (); // disables encryption for selected entries

Trabajar con contraseñas

Soporte implementado para métodos de cifrado:

  • PhpZipConstantsZipEncryptionMethod::PKWARE - Cifrado PKWARE tradicional (heredado)
  • PhpZipConstantsZipEncryptionMethod::WINZIP_AES_256 - Cifrado WinZip AES de 256 bits (recomendado)
  • PhpZipConstantsZipEncryptionMethod::WINZIP_AES_192 - Cifrado WinZip AES de 192 bits
  • PhpZipConstantsZipEncryptionMethod::WINZIP_AES_128 - Cifrado WinZip AES de 128 bits
Archivo Zip::setReadPassword

Establezca la contraseña para el archivo abierto.

No es necesario establecer una contraseña para agregar nuevas entradas o eliminar las existentes, pero si desea extraer el contenido o cambiar el método/nivel de compresión, el método de cifrado o cambiar la contraseña, en este caso se debe especificar la contraseña. 

 $ zipFile -> setReadPassword ( $ password );
Archivo Zip::setReadPasswordEntry

Obtiene una contraseña para leer una entrada definida por su nombre. 

 $ zipFile -> setReadPasswordEntry ( $ entryName , $ password );
Archivo Zip::establecer contraseña

Establece una nueva contraseña para todos los archivos del archivo.

Tenga en cuenta que este método no se aplica a las entradas que se agregan después de ejecutar este método. 

 $ zipFile -> setPassword ( $ password );

Puede configurar el método de cifrado: 

 $ encryptionMethod =  PhpZip  Constants ZipEncryptionMethod:: WINZIP_AES_256 ;
$ zipFile -> setPassword ( $ password , $ encryptionMethod );
Archivo Zip::setPasswordEntry

Establece una nueva contraseña para una entrada definida por su nombre. 

 $ zipFile -> setPasswordEntry ( $ entryName , $ password );

Puede configurar el método de cifrado: 

 $ encryptionMethod =  PhpZip  Constants ZipEncryptionMethod:: WINZIP_AES_256 ;
$ zipFile -> setPasswordEntry ( $ entryName , $ password , $ encryptionMethod );
Archivo Zip::desactivarCifrado

Deshabilite el cifrado para todas las entradas que ya están en el archivo.

Tenga en cuenta que este método no se aplica a las entradas que se agregan después de ejecutar este método. 

 $ zipFile -> disableEncryption ();
Archivo Zip::disableEncryptionEntry

Deshabilite el cifrado de una entrada definida por su nombre. 

 $ zipFile -> disableEncryptionEntry ( $ entryName );

Deshacer cambios

Archivo Zip::unchangeAll

Deshaga todos los cambios realizados en el archivo. 

 $ zipFile -> unchangeAll ();
Archivo Zip::unchangeArchivoComentario

Deshacer cambios en el comentario del archivo. 

 $ zipFile -> unchangeArchiveComment ();
Archivo Zip::unchangeEntry

Deshacer cambios de una entrada definida por su nombre. 

 $ zipFile -> unchangeEntry ( $ entryName );

Guardar un archivo o salida en un navegador

Archivo Zip::guardar como archivo

Guarda el archivo en un archivo. 

 $ zipFile -> saveAsFile ( $ filename );
Archivo Zip::saveAsStream

Escribe el archivo en la secuencia. 

 // $fp = fopen($filename, 'w+b');

$ zipFile -> saveAsStream ( $ fp );
Archivo Zip::salidaAsString

Genera un archivo ZIP como una cadena. 

 $ rawZipArchiveBytes = $ zipFile -> outputAsString ();
Archivo Zip::salidaComoAdjunto

Envía un archivo ZIP al navegador. 

 $ zipFile -> outputAsAttachment ( $ outputFilename );

Puede configurar el tipo Mime: 

 $ mimeType = ' application/zip ' ;
$ zipFile -> outputAsAttachment ( $ outputFilename , $ mimeType );
Archivo Zip::salidaAsPsr7Respuesta

Genera un archivo ZIP como respuesta PSR-7.

El método de salida se puede utilizar en cualquier marco compatible con PSR-7. 

 // $response = ....; // instance PsrHttpMessageResponseInterface
$ zipFile -> outputAsPsr7Response ( $ response , $ outputFilename );

Puede configurar el tipo Mime: 

 $ mimeType = ' application/zip ' ;
$ zipFile -> outputAsPsr7Response ( $ response , $ outputFilename , $ mimeType );
Archivo Zip::salidaAsSymfonyResponse

Genera un archivo ZIP como Symfony Response.

El método de salida se puede utilizar en el marco Symfony. 

 $ response = $ zipFile -> outputAsSymfonyResponse ( $ outputFilename );

Puede configurar el tipo Mime: 

 $ mimeType = ' application/zip ' ;
$ response = $ zipFile -> outputAsSymfonyResponse ( $ outputFilename , $ mimeType );

Ejemplo de uso en el controlador Symfony: 

 <?php

namespace App  Controller ;

use PhpZip  ZipFile ;
use Symfony  Component  HttpFoundation  Response ;
use Symfony  Component  Routing  Annotation  Route ;

class DownloadZipController
{
    /**
     * @Route("/downloads/{id}")
     *
     * @throws PhpZipExceptionZipException
     */
    public function __invoke ( string $ id ): Response
    {
        $ zipFile = new ZipFile ();
        $ zipFile [ ' file ' ] = ' contents ' ;

        $ outputFilename = $ id . ' .zip ' ;
        return $ zipFile -> outputAsSymfonyResponse ( $ outputFilename );
    }
}
Archivo Zip::reescribir

Guarde los cambios y vuelva a abrir el archivo modificado. 

 $ zipFile -> rewrite ();

Cerrando el archivo

Archivo Zip::cerrar

Cierra el archivo. 

 $ zipFile -> close ();

ejecutando las pruebas

Instalar las dependencias para el desarrollo: 

composer install --dev

Ejecute las pruebas: 

vendor/bin/phpunit

Registro de cambios

Los cambios están documentados en la página de lanzamientos.

Mejora

Actualice la versión 3 a la versión 4

Actualice la versión principal en el archivo composer.json a ^4.0 . 

{
    "require" : {
        "nelexa/zip" : " ^4.0 "
    }
}

Luego instale las actualizaciones usando Composer : 

composer update nelexa/zip

Actualice su código para que funcione con la nueva versión: BC

  • Se eliminaron clases y métodos obsoletos.
  • eliminado zipalign funcional. Esta funcionalidad se colocará en un paquete separado nelexa/apkfile .

Actualizar la versión 2 a la versión 3

Actualice la versión principal en el archivo composer.json a ^3.0 . 

{
    "require" : {
        "nelexa/zip" : " ^3.0 "
    }
}

Luego instale las actualizaciones usando Composer : 

composer update nelexa/zip

Actualice su código para que funcione con la nueva versión:

  • La clase ZipOutputFile se fusionó con ZipFile y se eliminó.
    • new PhpZipZipOutputFile() a new PhpZipZipFile()
  • Los métodos de inicialización estáticos ahora no son estáticos.
    • PhpZipZipFile::openFromFile($filename); a (new PhpZipZipFile())->openFile($filename);
    • PhpZipZipOutputFile::openFromFile($filename); a (new PhpZipZipFile())->openFile($filename);
    • PhpZipZipFile::openFromString($contents); a (new PhpZipZipFile())->openFromString($contents);
    • PhpZipZipFile::openFromStream($stream); a (new PhpZipZipFile())->openFromStream($stream);
    • PhpZipZipOutputFile::create() a new PhpZipZipFile()
    • PhpZipZipOutputFile::openFromZipFile(PhpZipZipFile $zipFile) > (new PhpZipZipFile())->openFile($filename);
  • Cambiar el nombre de los métodos:
    • addFromFile a addFile
    • setLevel para setCompressionLevel
    • ZipFile::setPassword a ZipFile::withReadPassword
    • ZipOutputFile::setPassword a ZipFile::withNewPassword
    • ZipOutputFile::disableEncryptionAllEntries to ZipFile::withoutPassword
    • ZipOutputFile::setComment a ZipFile::setArchiveComment
    • ZipFile::getComment a ZipFile::getArchiveComment
  • Se cambió la firma de los métodos addDir , addFilesFromGlob , addFilesFromRegex .
  • Eliminar métodos:
    • getLevel
    • setCompressionMethod
    • setEntryPassword
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo