php zip

PhpZip é uma biblioteca php para trabalho estendido com arquivos ZIP.

Documentação Russa

Versões e Dependências

Versão	PHP	Documentação
^4,0 (mestre)	^7,4|^8,0	atual
^3,0	^5,5|^7,0	Documentos v3.3

Índice

• Características
• Requisitos
• Instalação
• Exemplos
• Glossário
• Documentação
  • Visão geral dos métodos da classe PhpZipZipFile
  • Criação/Abertura de arquivo ZIP
  • Lendo entradas do arquivo
  • Iterando entradas
  • Obtendo informações sobre entradas
  • Adicionando entradas ao arquivo
  • Excluindo entradas do arquivo
  • Trabalhando com entradas e arquivo
  • Trabalhando com senhas
  • Desfazer alterações
  • Salvando um arquivo ou saída em um navegador
  • Fechando o arquivo
• Executando os testes
• Registro de alterações
• Atualizar
  • Atualize a versão 3 para a versão 4
  • Atualize a versão 2 para a versão 3

Características

• Abrindo e descompactando arquivos zip.
• Criando arquivos ZIP.
• Modificando arquivos ZIP.
• PHP puro (não requer extensão php-zip e classe ZipArchive ).
• Ele suporta salvar o arquivo em um arquivo, enviá-lo para o navegador ou enviá-lo como uma string sem salvá-lo em um arquivo.
• Comentários de arquivo e comentários de entrada individual são suportados.
• Obtenha informações sobre cada entrada no arquivo.
• Somente os seguintes métodos de compactação são suportados:
  • Não compactado (armazenado).
  • Esvazie a compressão.
  • Compressão BZIP2 com a extensão php-bz2 .
• Suporte para ZIP64 (o tamanho do arquivo é superior a 4 GB ou o número de entradas no arquivo é superior a 65.535).
• Trabalhando com senhas

  Atenção!

  Para sistemas de 32 bits, o método de criptografia Traditional PKWARE Encryption (ZipCrypto) não é suportado atualmente. Utilize o método de criptografia WinZIP AES Encryption , sempre que possível.

  • Defina a senha para ler o arquivo para todas as entradas ou apenas para algumas.
  • Altere a senha do arquivo, inclusive para entradas individuais.
  • Exclua a senha do arquivo para todas as entradas ou entradas individuais.
  • Defina a senha e/ou o método de criptografia, tanto para todas quanto para entradas individuais no arquivo.
  • Defina diferentes senhas e métodos de criptografia para diferentes entradas.
  • Exclua a senha de todas ou algumas entradas.
  • Suporta métodos de Traditional PKWARE Encryption (ZipCrypto) e WinZIP AES Encryption .
  • Defina o método de criptografia para todas ou entradas individuais no arquivo.

Requisitos

• PHP >= 7.4 ou PHP >= 8.0 (de preferência 64 bits).
• Extensão php opcional bzip2 para compactação BZIP2.
• openssl de extensão php opcional para suporte WinZip Aes Encryption .

Instalação

composer require nelexa/zip

Versão estável mais recente:

Exemplos

 // 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 ();
}

Outros exemplos podem ser encontrados na pasta tests/

Glossário

Entrada Zip - arquivo ou pasta em um arquivo ZIP. Cada entrada no arquivo possui certas propriedades, por exemplo: nome do arquivo, método de compactação, método de criptografia, tamanho do arquivo antes da compactação, tamanho do arquivo após a compactação, CRC32 e outros.

Documentação:

Visão geral dos métodos da classe PhpZipZipFile

• ZipFile::__construct - inicializa o arquivo ZIP.
• ZipFile::addAll - adiciona todas as entradas de um array.
• ZipFile::addDir - adiciona arquivos ao arquivo morto do diretório no caminho especificado sem subdiretórios.
• ZipFile::addDirRecursive - adiciona arquivos ao arquivo morto do diretório no caminho especificado com subdiretórios.
• ZipFile::addEmptyDir - adiciona um novo diretório.
• ZipFile::addFile - adiciona um arquivo a um arquivo ZIP a partir do caminho fornecido.
• ZipFile::addSplFile - adiciona um SplFileInfo a um arquivo ZIP.
• ZipFile::addFromFinder - adiciona arquivos do SymfonyComponentFinderFinder a um arquivo ZIP.
• ZipFile::addFilesFromIterator - adiciona arquivos do iterador de diretórios.
• ZipFile::addFilesFromGlob - adiciona arquivos de um diretório por padrão glob sem subdiretórios.
• ZipFile::addFilesFromGlobRecursive - adiciona arquivos de um diretório por padrão glob com subdiretórios.
• ZipFile::addFilesFromRegex - adiciona arquivos de um diretório pelo padrão PCRE sem subdiretórios.
• ZipFile::addFilesFromRegexRecursive - adiciona arquivos de um diretório pelo padrão PCRE com subdiretórios.
• ZipFile::addFromStream - adiciona uma entrada do fluxo ao arquivo ZIP.
• ZipFile::addFromString - adiciona um arquivo a um arquivo ZIP usando seu conteúdo.
• ZipFile::close - fecha o arquivo.
• ZipFile::count - retorna o número de entradas no arquivo.
• ZipFile::deleteFromName - exclui uma entrada no arquivo usando seu nome.
• ZipFile::deleteFromGlob - exclui uma entrada no arquivo usando o padrão glob.
• ZipFile::deleteFromRegex - exclui entradas do arquivo usando o padrão PCRE.
• ZipFile::deleteAll - exclui todas as entradas no arquivo ZIP.
• ZipFile::disableEncryption - desabilita a criptografia para todas as entradas que já estão no arquivo.
• ZipFile::disableEncryptionEntry - desativa a criptografia de uma entrada definida por seu nome.
• ZipFile::extractTo - extrai o conteúdo do arquivo.
• ZipFile::getArchiveComment - retorna o comentário do arquivo Zip.
• ZipFile::getEntryComment - retorna o comentário de uma entrada usando o nome da entrada.
• ZipFile::getEntryContent - retorna o conteúdo da entrada usando seu nome.
• ZipFile::getListFiles - retorna uma lista de arquivos compactados.
• ZipFile::hasEntry - verifica se existe uma entrada no arquivo.
• ZipFile::isDirectory - verifica se a entrada no arquivo é um diretório.
• ZipFile::matcher - seleciona entradas no arquivo para realizar operações nelas.
• ZipFile::openFile - abre um arquivo zip de um arquivo.
• ZipFile::openFromString - abre um arquivo zip a partir de uma string.
• ZipFile::openFromStream - abre um arquivo zip do stream.
• ZipFile::outputAsAttachment - gera um arquivo ZIP para o navegador.
• ZipFile::outputAsPsr7Response - gera um arquivo ZIP como resposta PSR-7.
• ZipFile::outputAsSymfonyResponse - gera um arquivo ZIP como resposta do Symfony.
• ZipFile::outputAsString - gera um arquivo ZIP como string.
• ZipFile::rename - renomeia uma entrada definida por seu nome.
• ZipFile::rewrite - salva as alterações e reabre o arquivo alterado.
• ZipFile::saveAsFile - salva o arquivo em um arquivo.
• ZipFile::saveAsStream - grava o arquivo no fluxo.
• ZipFile::setArchiveComment - define o comentário de um arquivo ZIP.
• ZipFile::setCompressionLevel - define o nível de compactação para todos os arquivos no arquivo.
• ZipFile::setCompressionLevelEntry - define o nível de compactação da entrada pelo seu nome.
• ZipFile::setCompressionMethodEntry - define o método de compactação para a entrada por seu nome.
• ZipFile::setEntryComment - define o comentário de uma entrada definida por seu nome.
• ZipFile::setReadPassword - define a senha para o arquivo aberto.
• ZipFile::setReadPasswordEntry - define uma senha para leitura de uma entrada definida por seu nome.
• ZipFile::setPassword - define uma nova senha para todos os arquivos do arquivo.
• ZipFile::setPasswordEntry - define uma nova senha de uma entrada definida por seu nome.
• ZipFile::unchangeAll - desfaz todas as alterações feitas no arquivo.
• ZipFile::unchangeArchiveComment - desfaz alterações no comentário do arquivo.
• ZipFile::unchangeEntry - desfaz alterações de uma entrada definida por seu nome.

Criação/Abertura de arquivo ZIP

Arquivo Zip::__construct**

Inicializa o arquivo ZIP

 $ zipFile = new  PhpZip  ZipFile ();

ZipFile::openFile

Abre um arquivo zip de um arquivo.

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

ZipFile::openFromString

Abre um arquivo zip a partir de uma string.

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> openFromString ( $ stringContents );

ZipFile::openFromStream

Abre um arquivo zip do stream.

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

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

Lendo entradas do arquivo

ZipFile::contagem

Retorna o número de entradas no arquivo.

 $ zipFile = new  PhpZip  ZipFile ();

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

ZipFile::getListFiles

Retorna uma lista de arquivos compactados.

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

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

ZipFile::getEntryContent

Retorna o conteúdo da entrada usando seu nome.

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

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

ZipFile::hasEntry

Verifica se há uma entrada no arquivo.

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

$ hasEntry = isset ( $ zipFile [ $ entryName ]);
// or
$ hasEntry = $ zipFile -> hasEntry ( $ entryName );

ZipFile::isDiretório

Verifica se a entrada no arquivo é um diretório.

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

$ isDirectory = $ zipFile -> isDirectory ( $ entryName );

ZipFile::extractTo

Extraia o conteúdo do arquivo. O diretório deve existir.

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

Extraia alguns arquivos para o diretório. O diretório deve existir.

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

Iterando entradas

ZipFile é um iterador. Pode iterar todas as entradas no loop foreach .

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

Pode iterar através do 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 ();
}

Obtendo informações sobre entradas

ZipFile::getArchiveComment

Retorna o comentário do arquivo Zip.

 $ zipFile = new  PhpZip  ZipFile ();
$ commentArchive = $ zipFile -> getArchiveComment ();

ZipFile::getEntryComment

Retorna o comentário de uma entrada usando o nome da entrada.

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

Adicionando entradas ao arquivo

Todos os métodos de adição de entradas a um arquivo ZIP permitem especificar um método para compactar o conteúdo.

Os seguintes métodos de compactação estão disponíveis:

• PhpZipConstantsZipCompressionMethod::STORED - sem compactação
• PhpZipConstantsZipCompressionMethod::DEFLATED - Esvaziar compactação
• PhpZipConstantsZipCompressionMethod::BZIP2 - Compressão Bzip2 com a extensão ext-bz2

ZipFile::addFile

Adiciona um arquivo a um arquivo ZIP do caminho fornecido.

 $ 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 

ZipFile::addSplFile

Adiciona um SplFileInfo a um arquivo 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 ,
]);

ZipFile::addFromFinder

Adiciona arquivos do SymfonyComponentFinderFinder a um arquivo 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 ' )
]);

ZipFile::addFromString

Adiciona um arquivo a um arquivo ZIP usando seu conteúdo.

 $ 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 

ZipFile::addFromStream

Adiciona uma entrada do fluxo ao arquivo 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 

ZipFile::addEmptyDir

Adicione um novo diretório.

 $ zipFile = new  PhpZip  ZipFile ();
// $path = "path/to/";
$ zipFile -> addEmptyDir ( $ path );
// or
$ zipFile [ $ path ] = null ;

ZipFile::addAll

Adiciona todas as entradas de uma 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 );

ZipFile::addDir

Adiciona arquivos ao arquivo morto do diretório no caminho especificado sem subdiretórios.

 $ 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 

ZipFile::addDirRecursivo

Adiciona arquivos ao arquivo morto do diretório no caminho especificado com subdiretórios.

 $ 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::addFilesFromIterator

Adiciona arquivos do iterador de diretórios.

 // $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

Exemplo com alguns arquivos 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 );

ZipFile::addFilesFromGlob

Adiciona arquivos de um diretório por padrão glob sem subdiretórios.

 $ 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

Adiciona arquivos de um diretório por padrão glob com subdiretórios.

 $ 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 

ZipFile::addFilesFromRegex

Adiciona arquivos de um diretório pelo padrão PCRE sem subdiretórios.

 $ 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

Adiciona arquivos de um diretório por padrão PCRE com subdiretórios.

 $ 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 

Excluindo entradas do arquivo

ZipFile::deleteFromName

Exclui uma entrada no arquivo usando seu nome.

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

ZipFile::deleteFromGlob

Exclui entradas no arquivo usando o padrão glob.

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

$ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> deleteFromGlob ( $ globPattern );

ZipFile::deleteFromRegex

Exclui entradas do arquivo usando o padrão 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 );

ZipFile::deleteAll

Exclui todas as entradas do arquivo ZIP.

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

Trabalhando com entradas e arquivo

ZipFile::renomear

Renomeia uma entrada definida pelo seu nome.

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> rename ( $ oldName , $ newName );

ZipFile::setCompressionLevel

Defina o nível de compactação para todos os arquivos do arquivo.

Observe que este método não se aplica a entradas adicionadas após a execução desse método.

Por padrão, o nível de compactação é 5 ( PhpZipConstantsZipCompressionLevel::NORMAL ) ou o nível de compactação especificado no arquivo para compactação Deflate.

Os valores variam de 1 ( PhpZipConstantsZipCompressionLevel::SUPER_FAST ) a 9 ( PhpZipConstantsZipCompressionLevel::MAXIMUM ) são suportados. Quanto maior o número, melhor e mais longa será a compactação.

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

ZipFile::setCompressionLevelEntry

Define o nível de compactação da entrada pelo seu nome.

Os valores variam de 1 ( PhpZipConstantsZipCompressionLevel::SUPER_FAST ) a 9 ( PhpZipConstantsZipCompressionLevel::MAXIMUM ) são suportados. Quanto maior o número, melhor e mais longa será a compactação.

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

ZipFile::setCompressionMethodEntry

Define o método de compactação da entrada pelo seu nome.

Os seguintes métodos de compactação estão disponíveis:

• PhpZipConstantsZipCompressionMethod::STORED - Sem compactação
• PhpZipConstantsZipCompressionMethod::DEFLATED - Esvaziar compactação
• PhpZipConstantsZipCompressionMethod::BZIP2 - Compressão Bzip2 com a extensão ext-bz2

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setCompressionMethodEntry ( $ entryName ,  PhpZip  Constants ZipCompressionMethod:: DEFLATED );

ZipFile::setArchiveComment

Defina o comentário de um arquivo ZIP.

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setArchiveComment ( $ commentArchive );

ZipFile::setEntryComment

Defina o comentário de uma entrada definida pelo seu nome.

 $ zipFile = new  PhpZip  ZipFile ();
$ zipFile -> setEntryComment ( $ entryName , $ comment );

ZipFile::matcher

Selecionar entradas no arquivo para realizar operações nelas.

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

Selecionando arquivos do arquivo, um de cada vez:

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

Selecione vários arquivos no arquivo:

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

Selecionando arquivos por expressão regular:

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

Selecione todos os arquivos no arquivo:

 $ matcher -> all ();

count() - obtém o número de entradas selecionadas:

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

getMatches() – retorna uma lista de entradas selecionadas:

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

invocar() - invoca uma função que pode ser chamada nas entradas selecionadas:

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

Funções para trabalhar nas entradas selecionadas:

 $ 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 

Trabalhando com senhas

Suporte implementado para métodos de criptografia:

• PhpZipConstantsZipEncryptionMethod::PKWARE - Criptografia PKWARE tradicional (legado)
• PhpZipConstantsZipEncryptionMethod::WINZIP_AES_256 - Criptografia WinZip AES de 256 bits (recomendado)
• PhpZipConstantsZipEncryptionMethod::WINZIP_AES_192 - Criptografia WinZip AES de 192 bits
• PhpZipConstantsZipEncryptionMethod::WINZIP_AES_128 - Criptografia WinZip AES de 128 bits

ZipFile::setReadPassword

Defina a senha para o arquivo aberto.

A configuração de uma senha não é necessária para adicionar novas entradas ou excluir as existentes, mas se você deseja extrair o conteúdo ou alterar o método/nível de compactação, o método de criptografia ou alterar a senha, neste caso a senha deve ser especificada.

 $ zipFile -> setReadPassword ( $ password );

ZipFile::setReadPasswordEntry

Obtém uma senha para leitura de uma entrada definida pelo seu nome.

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

ZipFile::setPassword

Define uma nova senha para todos os arquivos do arquivo.

Observe que este método não se aplica a entradas adicionadas após a execução desse método.

 $ zipFile -> setPassword ( $ password );

Você pode definir o método de criptografia:

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

ZipFile::setPasswordEntry

Define uma nova senha de uma entrada definida pelo seu nome.

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

Você pode definir o método de criptografia:

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

ZipFile::disableEncryption

Desative a criptografia para todas as entradas que já estão no arquivo.

Observe que este método não se aplica a entradas adicionadas após a execução desse método.

 $ zipFile -> disableEncryption ();

ZipFile::disableEncryptionEntry

Desative a criptografia de uma entrada definida pelo seu nome.

 $ zipFile -> disableEncryptionEntry ( $ entryName );

Desfazer alterações

ZipFile::unchangeAll

Desfaça todas as alterações feitas no arquivo.

 $ zipFile -> unchangeAll ();

ZipFile::unchangeArchiveComment

Desfaça alterações no comentário do arquivo.

 $ zipFile -> unchangeArchiveComment ();

ZipFile::unchangeEntry

Desfazer alterações de uma entrada definida pelo seu nome.

 $ zipFile -> unchangeEntry ( $ entryName );

Salvando um arquivo ou saída em um navegador

ZipFile::saveAsFile

Salva o arquivo em um arquivo.

 $ zipFile -> saveAsFile ( $ filename );

ZipFile::saveAsStream

Grava o arquivo no fluxo.

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

$ zipFile -> saveAsStream ( $ fp );

ZipFile::outputAsString

Produz um arquivo ZIP como string.

 $ rawZipArchiveBytes = $ zipFile -> outputAsString ();

ZipFile::outputAsAttachment

Produz um arquivo ZIP para o navegador.

 $ zipFile -> outputAsAttachment ( $ outputFilename );

Você pode definir o tipo Mime:

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

ZipFile::outputAsPsr7Response

Produz um arquivo ZIP como resposta PSR-7.

O método de saída pode ser usado em qualquer estrutura compatível com PSR-7.

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

Você pode definir o tipo Mime:

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

ZipFile::outputAsSymfonyResponse

Produz um arquivo ZIP como resposta do Symfony.

O método de saída pode ser usado no framework Symfony.

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

Você pode definir o tipo Mime:

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

Exemplo de uso no Symfony Controller:

 <?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 );
    }
}

ZipFile::reescrever

Salve as alterações e reabra o arquivo alterado.

 $ zipFile -> rewrite ();

Fechando o arquivo

ZipFile::fechar

Feche o arquivo.

 $ zipFile -> close ();

Executando os testes

Instale as dependências para o desenvolvimento:

composer install --dev

Execute os testes:

vendor/bin/phpunit

Registro de alterações

As alterações estão documentadas na página de lançamentos.

Atualizar

Atualize a versão 3 para a versão 4

Atualize a versão principal no arquivo composer.json para ^4.0 .

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

Em seguida, instale as atualizações usando Composer :

composer update nelexa/zip

Atualize seu código para funcionar com a nova versão: BC

• removeu classes e métodos obsoletos.
• funcional zipalign removido. Esta funcionalidade será colocada em um pacote separado nelexa/apkfile .

Atualize a versão 2 para a versão 3

Atualize a versão principal no arquivo composer.json para ^3.0 .

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

Em seguida, instale as atualizações usando Composer :

composer update nelexa/zip

Atualize seu código para funcionar com a nova versão:

• Classe ZipOutputFile mesclada com ZipFile e removida.
  • new PhpZipZipOutputFile() para new PhpZipZipFile()
• Os métodos de inicialização estáticos agora não são estáticos.
  • PhpZipZipFile::openFromFile($filename); para (new PhpZipZipFile())->openFile($filename);
  • PhpZipZipOutputFile::openFromFile($filename); para (new PhpZipZipFile())->openFile($filename);
  • PhpZipZipFile::openFromString($contents); para (new PhpZipZipFile())->openFromString($contents);
  • PhpZipZipFile::openFromStream($stream); para (new PhpZipZipFile())->openFromStream($stream);
  • PhpZipZipOutputFile::create() para new PhpZipZipFile()
  • PhpZipZipOutputFile::openFromZipFile(PhpZipZipFile $zipFile) > (new PhpZipZipFile())->openFile($filename);
• Renomear métodos:
  • addFromFile para addFile
  • setLevel para setCompressionLevel
  • ZipFile::setPassword para ZipFile::withReadPassword
  • ZipOutputFile::setPassword para ZipFile::withNewPassword
  • ZipOutputFile::disableEncryptionAllEntries para ZipFile::withoutPassword
  • ZipOutputFile::setComment para ZipFile::setArchiveComment
  • ZipFile::getComment para ZipFile::getArchiveComment
• Assinatura alterada para métodos addDir , addFilesFromGlob , addFilesFromRegex .
• Remover métodos:
  • getLevel
  • setCompressionMethod
  • setEntryPassword