Deprecated: The each() function is deprecated. This message will be suppressed on further calls in /home/zhenxiangba/zhenxiangba.com/public_html/phproxy-improved-master/index.php on line 456
PHP: Zip 関数 - Manual
[go: Go Back, main page]
PHP
downloads | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

zip_close" width="11" height="7"/> <Zip
Last updated: Fri, 05 Sep 2008

view this page in

Zip 関数

目次



zip_close" width="11" height="7"/> <Zip
Last updated: Fri, 05 Sep 2008
 
add a note add a note User Contributed Notes
Zip 関数
phillpafford+php at gmail dot com
12-Jun-2008 10:28
You could just use the linux commands

<?php

// Get the date
$date = date("m-d-y");

// Make Zip name
$zipname = "archive/site-script-backup." . $date . ".zip";

// Make a zip file
$cmd = `zip -r $zipname *`;

?>
fgarciarico at gmail dot com
27-May-2008 03:19
Using the same scripts as the last message:

\libraries\zip.lib.php
\libraries\unzip.lib.php

you can also extract all the files included in a zip file. This is my own example:

require_once("zip.lib.php");
require_once("unzip.lib.php");

$zip = new SimpleUnzip();
$filename = "myzippedfile.zip";
$entries = $zip->ReadFile($filename);

foreach ($entries as $entry){
     $fh = fopen($entry->Name, 'w', false);
    fwrite($fh,$entry->Data);
    fclose($fh);
}
cusimar9 at hotmail dot com
14-May-2008 01:06
Just to second the comments above and say that the zipfile class in phpMyAdmin is excellent.

There are 2 files when you download phpMyAdmin:

\libraries\zip.lib.php
\libraries\unzip.lib.php

Here is a small example:

$zip = new zipfile();
$filename = "1.jpg";
$fsize = @filesize($filename);
$fh = fopen($filename, 'rb', false);
$data = fread($fh, $fsize);             
$zip->addFile($data,$filename);

$zipcontents = $zip->file();

header("Content-type: application/octet-stream");
header("Content-Disposition: attachment; filename=\"TheZip.zip\"");
header("Content-length: " . strlen($zipcontents) . "\n\n");

// output data
echo $zipcontents;
rodrigo dot moraes at gmail dot com
30-Jan-2008 12:56
Here's a more simple extended class to add a whole directory recursively, keeping the same structure. It uses SPL.

<?php
class MyZipArchive extends ZipArchive
{
    /**
     *
     * Adds a directory recursively.
     *
     * @param string $filename The path to the file to add.
     *
     * @param string $localname Local name inside ZIP archive.
     *
     */
    public function addDir($filename, $localname)
    {
        $this->addEmptyDir($localname);
        $iter = new RecursiveDirectoryIterator($filename);

        foreach ($iter as $fileinfo) {
            if (! $fileinfo->isFile() && !$fileinfo->isDir()) {
                continue;
            }

            $method = $fileinfo->isFile() ? 'addFile' : 'addDir';
            $this->$method($fileinfo->getPathname(), $localname . '/' .
                $fileinfo->getFilename());
        }
    }
}
?>
mmj48 at gmail dot com
08-Nov-2007 10:39
Heres a function I wrote that will extract a zip file with the same directory structure...

Enjoy:

<?php
function unzip($zipfile)
{
    $zip = zip_open($zipfile);
    while ($zip_entry = zip_read($zip))    {
        zip_entry_open($zip, $zip_entry);
        if (substr(zip_entry_name($zip_entry), -1) == '/') {
            $zdir = substr(zip_entry_name($zip_entry), 0, -1);
            if (file_exists($zdir)) {
                trigger_error('Directory "<b>' . $zdir . '</b>" exists', E_USER_ERROR);
                return false;
            }
            mkdir($zdir);
        }
        else {
            $name = zip_entry_name($zip_entry);
            if (file_exists($name)) {
                trigger_error('File "<b>' . $name . '</b>" exists', E_USER_ERROR);
                return false;
            }
            $fopen = fopen($name, "w");
            fwrite($fopen, zip_entry_read($zip_entry, zip_entry_filesize($zip_entry)), zip_entry_filesize($zip_entry));
        }
        zip_entry_close($zip_entry);
    }
    zip_close($zip);
    return true;
}
?>
nheimann at gmx dot net
04-Nov-2007 12:19
With this extension you can Add dirs with files with the ZipArchive Object

/**
 * FlxZipArchive, Extends ZipArchiv.
 * Add Dirs with Files and Subdirs.
 *
 * <code>
 *  $archive = new FlxZipArchive;
 *  // .....
 *  $archive->addDir( 'test/blub', 'blub' );
 * </code>
 */
class FlxZipArchive extends ZipArchive {
    /**
     * Add a Dir with Files and Subdirs to the archive
     *
     * @param string $location Real Location
     * @param string $name Name in Archive
     * @author Nicolas Heimann
     * @access private
     **/

    public function addDir($location, $name) {
        $this->addEmptyDir($name);

        $this->addDirDo($location, $name);
//     } // EO addDir;

    /**
     * Add Files & Dirs to archive.
     *
     * @param string $location Real Location
     * @param string $name Name in Archive
     * @author Nicolas Heimann
     * @access private
     **/

    private function addDirDo($location, $name) {
        $name .= '/';
        $location .= '/';

        // Read all Files in Dir
        $dir = opendir ($location);
        while ($file = readdir($dir))
        {
            if ($file == '.' || $file == '..') continue;

            // Rekursiv, If dir: FlxZipArchive::addDir(), else ::File();
            $do = (filetype() == 'dir') ? 'addDir' : 'addFile';
            $this->$do($location . $file, $name . $file);
        }
    } // EO addDirDo();
}
bushj at rpi dot edu
26-Jun-2007 02:59
I made a zip stream handler in case your distribution does not have the built in one using the new ZipArchive system. This one also features the ability to grab entries by index as well as by name. It is similar in capabilities to the builtin gzip/bzip2 compression stream handlers (http://us2.php.net/manual/en/wrappers.compression.php) except it does not support writing.

To use:
fopen('zip://absolute/path/to/file.zip?entryname', $mode) or
fopen('zip://absolute/path/to/file.zip#entryindex', $mode) or
fopen('zip://absolute/path/to/file.zip', $mode)

$mode can only be 'r' or 'rb'. In the last case the first entry in the zip file is used.

<?php
class ZipStream {
  public $zip; //the zip file
  public $entry; //the opened zip entry
  public $length; //the uncompressed size of the zip entry
  public $position; //the current position in the zip entry read
  //Opens the zip file then retrieves and opens the entry to stream
  public function stream_open($path, $mode, $options, &$opened_path) {
    if ($mode != 'r' && $mode != 'rb') //only accept r and rb modes, no writing!
      return false;
    $path = 'file:///'.substr($path, 6); //switch out file:/// for zip:// so we can use url_parse
    $url = parse_url($path);
    //open the zip file
    $filename = $url['path'];
    $this->zip = zip_open($filename);
    if (!is_resource($this->zip))
      return false;

    //if entry name is given, find that entry   
    if (array_key_exists('query', $url) && $url['query']) {
      $path = $url['query'];
      do {
        $this->entry = zip_read($this->zip);
        if (!is_resource($this->entry))
          return false;
      } while (zip_entry_name($this->entry) != $path);    
    } else { //otherwise get it by index (default to 0)
      $id = 0;
      if (array_key_exists('fragment', $url) && is_int($url['fragment']))
        $id = $url['fragment']*1;
      for ($i = 0; $i <= $id; $i++) {
        $this->entry = zip_read($this->zip);
        if (!is_resource($this->entry))
          return false;
      }
    }
    //setup length and open the entry for reading
    $this->length = zip_entry_filesize($this->entry);
    $this->position = 0;
    zip_entry_open($this->zip, $this->entry, $mode);
    return true;
  }
  //Closes the zip entry and file
  public function stream_close() { @zip_entry_close($this->entry); @zip_close($this->zip); }
  //Returns how many bytes have been read from the zip entry
  public function stream_tell() { return $this->position; }
  //Returns true if the end of the zip entry has been reached
  public function stream_eof() { return $this->position >= $this->length; }
  //Returns the stat array, only 'size' is filled in with the uncompressed zip entry size
  public function url_stat() { return array('dev'=>0, 'ino'=>0, 'mode'=>0, 'nlink'=>0, 'uid'=>0, 'gid'=>0, 'rdev'=>0, 'size'=>$this->length, 'atime'=>0, 'mtime'=>0, 'ctime'=>0, 'blksize'=>0, 'blocks'=>0); }
  //Reads the next $count bytes or until the end of the zip entry. Returns the data or false if no data was read.
  public function stream_read($count) {
    $this->position += $count;
    if ($this->position > $this->length)
      $this->position = $this->length;
    return zip_entry_read($this->entry, $count);
  }
}
//Register the zip stream handler
stream_wrapper_register('zip', 'ZipStream'); //if this fails there is already a zip stream handler and we will just use that one
?>
martinlarsen at bigfoot dot com
08-Jun-2007 08:40
Lennart Poot's example of using phpMyAdmin's zip library is missing the echo that will actually output the final zip file.

At the end (but before the exit which isn't needed anyway), add this line:

echo $dump_buffer;
darkstream777 at gmx dot net
15-May-2007 08:19
Hi,
i modified the function from nielsvandenberge, now you
can also use relative path's, i added also error messages
and another small highlights, have fun.

<?php
/**
 * Unzip the source_file in the destination dir
 *
 * @param   string      The path to the ZIP-file.
 * @param   string      The path where the zipfile should be unpacked, if false the directory of the zip-file is used
 * @param   boolean     Indicates if the files will be unpacked in a directory with the name of the zip-file (true) or not (false) (only if the destination directory is set to false!)
 * @param   boolean     Overwrite existing files (true) or not (false)
 *
 * @return  boolean     Succesful or not
 */
function unzip($src_file, $dest_dir=false, $create_zip_name_dir=true, $overwrite=true)
{
  if(function_exists("zip_open"))
  {  
      if(!is_resource(zip_open($src_file)))
      {
          $src_file=dirname($_SERVER['SCRIPT_FILENAME'])."/".$src_file;
      }
     
      if (is_resource($zip = zip_open($src_file)))
      {         
          $splitter = ($create_zip_name_dir === true) ? "." : "/";
          if ($dest_dir === false) $dest_dir = substr($src_file, 0, strrpos($src_file, $splitter))."/";
        
          // Create the directories to the destination dir if they don't already exist
          create_dirs($dest_dir);

          // For every file in the zip-packet
          while ($zip_entry = zip_read($zip))
          {
            // Now we're going to create the directories in the destination directories
          
            // If the file is not in the root dir
            $pos_last_slash = strrpos(zip_entry_name($zip_entry), "/");
            if ($pos_last_slash !== false)
            {
              // Create the directory where the zip-entry should be saved (with a "/" at the end)
              create_dirs($dest_dir.substr(zip_entry_name($zip_entry), 0, $pos_last_slash+1));
            }

            // Open the entry
            if (zip_entry_open($zip,$zip_entry,"r"))
            {
            
              // The name of the file to save on the disk
              $file_name = $dest_dir.zip_entry_name($zip_entry);
            
              // Check if the files should be overwritten or not
              if ($overwrite === true || $overwrite === false && !is_file($file_name))
              {
                // Get the content of the zip entry
                $fstream = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));          
               
                if(!is_dir($file_name))           
                file_put_contents($file_name, $fstream );
                // Set the rights
                if(file_exists($file_name))
                {
                    chmod($file_name, 0777);
                    echo "<span style=\"color:#1da319;\">file saved: </span>".$file_name."<br />";
                }
                else
                {
                    echo "<span style=\"color:red;\">file not found: </span>".$file_name."<br />";
                }
              }
            
              // Close the entry
              zip_entry_close($zip_entry);
            }     
          }
          // Close the zip-file
          zip_close($zip);
      }
      else
      {
        echo "No Zip Archive Found.";
        return false;
      }
    
      return true;
  }
  else
  {
      if(version_compare(phpversion(), "5.2.0", "<"))
      $infoVersion="(use PHP 5.2.0 or later)";
     
      echo "You need to install/enable the php_zip.dll extension $infoVersion";
  }
}

function create_dirs($path)
{
  if (!is_dir($path))
  {
    $directory_path = "";
    $directories = explode("/",$path);
    array_pop($directories);
  
    foreach($directories as $directory)
    {
      $directory_path .= $directory."/";
      if (!is_dir($directory_path))
      {
        mkdir($directory_path);
        chmod($directory_path, 0777);
      }
    }
  }
}
?>

greetings darki777
nielsvandenberge at hotmail dot com
11-May-2007 06:29
This is the function I use to unzip a file.
It includes the following options:
* Unzip in any directory you like
* Unzip in the directory of the zip file
* Unzip in a directory with the zipfile's name in the directory of the zip file. (i.e.: C:\test.zip will be unzipped in  C:\test\)
* Overwrite existing files or not
* It creates non existing directories with the function Create_dirs($path)

You should use absolute paths with slashes (/) instead of backslashes (\).
I tested it with PHP 5.2.0 with php_zip.dll extension loaded

<?php
/**
 * Unzip the source_file in the destination dir
 *
 * @param   string      The path to the ZIP-file.
 * @param   string      The path where the zipfile should be unpacked, if false the directory of the zip-file is used
 * @param   boolean     Indicates if the files will be unpacked in a directory with the name of the zip-file (true) or not (false) (only if the destination directory is set to false!)
 * @param   boolean     Overwrite existing files (true) or not (false)
 * 
 * @return  boolean     Succesful or not
 */
function unzip($src_file, $dest_dir=false, $create_zip_name_dir=true, $overwrite=true)
{
  if ($zip = zip_open($src_file))
  {
    if ($zip)
    {
      $splitter = ($create_zip_name_dir === true) ? "." : "/";
      if ($dest_dir === false) $dest_dir = substr($src_file, 0, strrpos($src_file, $splitter))."/";
     
      // Create the directories to the destination dir if they don't already exist
      create_dirs($dest_dir);

      // For every file in the zip-packet
      while ($zip_entry = zip_read($zip))
      {
        // Now we're going to create the directories in the destination directories
       
        // If the file is not in the root dir
        $pos_last_slash = strrpos(zip_entry_name($zip_entry), "/");
        if ($pos_last_slash !== false)
        {
          // Create the directory where the zip-entry should be saved (with a "/" at the end)
          create_dirs($dest_dir.substr(zip_entry_name($zip_entry), 0, $pos_last_slash+1));
        }

        // Open the entry
        if (zip_entry_open($zip,$zip_entry,"r"))
        {
         
          // The name of the file to save on the disk
          $file_name = $dest_dir.zip_entry_name($zip_entry);
         
          // Check if the files should be overwritten or not
          if ($overwrite === true || $overwrite === false && !is_file($file_name))
          {
            // Get the content of the zip entry
            $fstream = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));

            file_put_contents($file_name, $fstream );
            // Set the rights
            chmod($file_name, 0777);
            echo "save: ".$file_name."<br />";
          }
         
          // Close the entry
          zip_entry_close($zip_entry);
        }      
      }
      // Close the zip-file
      zip_close($zip);
    }
  }
  else
  {
    return false;
  }
 
  return true;
}

/**
 * This function creates recursive directories if it doesn't already exist
 *
 * @param String  The path that should be created
 * 
 * @return  void
 */
function create_dirs($path)
{
  if (!is_dir($path))
  {
    $directory_path = "";
    $directories = explode("/",$path);
    array_pop($directories);
   
    foreach($directories as $directory)
    {
      $directory_path .= $directory."/";
      if (!is_dir($directory_path))
      {
        mkdir($directory_path);
        chmod($directory_path, 0777);
      }
    }
  }
}

// Extract C:/zipfiletest/zip-file.zip to C:/zipfiletest/zip-file/ and overwrites existing files
unzip("C:/zipfiletest/zip-file.zip", false, true, true);

// Extract C:/zipfiletest/zip-file.zip to C:/another_map/zipfiletest/ and doesn't overwrite existing files. NOTE: It doesn't create a map with the zip-file-name!
unzip("C:/zipfiletest/zip-file.zip", "C:/another_map/zipfiletest/", true, false);

?>
jeswanth@gmail
01-May-2007 04:55
Hi, all

There are lot of functions given below which etracts files, but what they lack is setting file permissions. On some servers file permissions are very important and the script cease to work after creating first directory, So I have added chmod to the code. There is only one limitation to the code, files without file extension are neither treated as files or directories so they are not chmoded, anyway this does not affect the code. Hope this helps.

<?php
function unpackZip($dir,$file) {
   if ($zip = zip_open($dir.$file.".zip")) {
     if ($zip) {
       mkdir($dir.$file);
     chmod($dir.$file, 0777);
       while ($zip_entry = zip_read($zip)) {
         if (zip_entry_open($zip,$zip_entry,"r")) {
           $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
           $dir_name = dirname(zip_entry_name($zip_entry));
           if ($dir_name != ".") {
             $dir_op = $dir.$file."/";
               foreach ( explode("/",$dir_name) as $k) {
                 $dir_op = $dir_op . $k;
                 if (is_file($dir_op)) unlink($dir_op);
                 if (!is_dir($dir_op)) mkdir($dir_op);
            chmod($dir_op, 0777);
                 $dir_op = $dir_op . "/" ;
                 }
               }
           $fp=fopen($dir.$file."/".zip_entry_name($zip_entry),"w+");
        chmod($dir.$file."/".zip_entry_name($zip_entry), 0777);
           fwrite($fp,$buf);

           fclose($fp);

           zip_entry_close($zip_entry);
       } else
           return false;
       }
       zip_close($zip);
     }
  } else
     return false;

  return true;
}

$dir = $_SERVER['DOCUMENT_ROOT']."/"."destdirectory/";
$file = 'zipfilename_without_extension';
unpackZip($dir,$file);
$print = $_SERVER['DOCUMENT_ROOT'];
?>
max at centdessin dot com
19-Oct-2006 04:19
I've needed a simple php class to manipulate zip files without PCEL extension, after reading all comment and tested 2 nice classes, here's my conclusion:

"You can use PHPMyAdmin's zip.lib"
-- Lennart Poot -- 12-Jul-2006 07:33

true, getting it is a bit awkward but the class is straight foward and works. BUT it only create zip files, it wont extract them.

"Hey guys, maybe you should check this out:
http://www.phpconcept.net/pclzip/index.en.php "
-- master_auer at web dot de -- 16-Nov-2003 07:49

true, check it if you need more advanced feature, this class is awsome.
bholub at chiefprojects dot com
18-Oct-2006 04:14
This will simply unpack (including directories) $zip to $dir -- in this example the zip is being uploaded.
<?php
    $dir = 'C:\\reports-temp\\';
    $zip = zip_open($_FILES['report_zip']['tmp_name']);
    while($zip_entry = zip_read($zip)) {
        $entry = zip_entry_open($zip,$zip_entry);
        $filename = zip_entry_name($zip_entry);
        $target_dir = $dir.substr($filename,0,strrpos($filename,'/'));
        $filesize = zip_entry_filesize($zip_entry);
        if (is_dir($target_dir) || mkdir($target_dir)) {
            if ($filesize > 0) {
                $contents = zip_entry_read($zip_entry, $filesize);
                file_put_contents($dir.$filename,$contents);
            }
        }
    }
?>
Mishania at ketsujin dot com
07-Oct-2006 12:39
Notes from phpContrib [ a t ] eSurfers D o t COM are a ROCK!!!

1)  In order to make it work U'll probably need:
 ** Allow Apache service to interact with desktop, but in that case U will notice momentarely console window opens and closes.  That's may be annoying.  The elegant solution instead of allowing interaction is redirect the command to some temporary file, and get rid of it later on:

define('UNZIP_CMD','unzip -o @_SRC_@ -x -d 
@_DST_@ > tmpfile.txt');

2)  I would recommend to use 7-zip, it's free and completely relyable.  Also, it's comes with stand alone console executable which makes it quite convenient to place it in some exec library folder within your source, and refferering directly to it.

define("UNZIP_CMD","7za.exe x @_SRC_@ -o@_DST_@ > tmpfile.txt");
24-Sep-2006 11:46
Previous poster's code is not using escape_shell_arg(), so it can be a huge security hole if attacker could manipulate filename/dir. I suggest replacing str_replace() with sprintf() and escape_shell_arg().
phpContrib [ a t ] eSurfers D o t COM
05-Sep-2006 06:35
1) A warning to all users of PHP Zipping/Unzipping Classes: most of them require the whole content of the ZIP file and/or the unzipped contents to stay in memory. They work very well, but might fail with very large files. Keep this in mind before starting development of a project involving large ZIP files.

2) If all you need is to unzip files to a folder, and your server has a zip command line tool, all you might need is a function like this:

if(!defined('UNZIP_CMD')) define('UNZIP_CMD','unzip -o @_SRC_@ -x -d 
@_DST_@');

function UnzipAllFiles($zipFile,$zipDir) {
    $unzipCmd=UNZIP_CMD;
    $unzipCmd=str_replace('@_SRC_@',$zipFile,$unzipCmd);
    $unzipCmd=str_replace('@_DST_@',$zipDir,$unzipCmd);
    $res=-1; // any nonzero value
    $UnusedArrayResult=array();
    $UnusedStringResult=exec($unzipCmd,$UnusedArrayResult,$res);
    return ($res==0);
}

// * * *  You DO NOT NEED the ZIP lib or M-ZIP to use this, but you will need the tool M-ZIP uses (unzip.exe or unzip for linux).  * * *

// Use it this way:

    $zipFile='/path/to/uploaded_file.zip';
    $whereToUnzip='/path/to/writable/folder/';

    $result=UnzipAllFiles($zipFile,$whereToUnzip);

    if($result===FALSE) echo('FAILED');
    else echo('SUCCESS');

By changing UNZIP_CMD (the same constant as in the m-zip lib) you can 
of course untar, unarc, unrar, etc... provided you have the correct 
unwhatever command or unwhatever.exe executable and write its correct syntax in UNZIP_CMD.

To see details of what tools you need and where to put them (or to use a syntax compatible to the standard zip lib) see http://eSurfers.com/m-zip/
Lennart Poot
12-Jul-2006 08:33
You can use PHPMyAdmin's zip.lib library. It's available in the package PHPMyAdmin ( http://www.phpmyadmin.net/  ).

The zip class is located in /libraries/zip.lib.php

Next example generates a file named 'subfolder_in_zip_archive/_settings.php' using information of variable $settings. All files in folder 'folder_holding_files_to_add_to_zip' ($ad_dir) will be added to the archive as well.

In this example the raw zip archive data is responded to the browser. Uncomment the lines after 'write the file to disk' if you would like the archive to be stored on disk.

The function $zipfile -> addFile requires two parameters.

- The first parameter holds raw data and needs to be escaped using php function ‘stripcslashes’
- The second parameter holds the filename in the archive. You can enter complete paths to create complex folder structures

A timestamp can be added using the third additional parameter.

Regars,

Lennart Poot

<?php
  require_once('zip.lib.php');
  $zipfilename = 'zip_archive_to_generate.zip';
  $zip_subfolder = 'subfolder_in_zip_archive';

  $settings = '
    <?php
      $setting1 = "'.$setting1.'";
      $setting2 = "'.$setting2.'";
    ?>
  ';

  $ad_dir = 'folder_holding_files_to_add_to_zip';

  // form is posted, handle it   
  $zipfile = new zipfile();

  // generate _settings into zip file
  $zipfile ->addFile( stripcslashes( $settings ), $zip_subfolder . '/_settings.php' );

  if ($handle = opendir($ad_dir)) {
     while (false !== ($file = readdir($handle))) {
        if (!is_dir($file) && $file != "." && $file != ".." ) {
          $f_tmp = @fopen( $ad_dir . '/' . $file, 'r');

          if($f_tmp){
            $dump_buffer=fread( $f_tmp, filesize($ad_dir . '/' . $file));
            $zipfile -> addFile($dump_buffer, $zip_subfolder . '/' . $file);
            fclose( $f_tmp );
          }
        }
     }  

  $dump_buffer = $zipfile -> file();
  // write the file to disk:
  /*
  $file_pointer = fopen('newzip.zip', 'w');
  if($file_pointer){
    fwrite( $file_pointer, $dump_buffer, strlen($dump_buffer) );
    fclose( $file_pointer );
  }
  */

  // response zip archive to browser:
  header('Pragma: public');
  header('Content-type: application/zip');
  header('Content-length: ' . strlen($dump_buffer));
  header('Content-Disposition: attachment; filename="'.$zipfilename.'"');

  exit;
?>
nospam at hostingfanatic dot com
12-May-2006 02:27
I needed a quick way to make a zip file from an entire directory including subdirectories. This is downright rough but if someone would fancy it up a bit it works good with the zip class at http://smiledsoft.com/demos/phpzip/ (free version).

Basic use in script would be...

make_archive("the/directory", $zip_archive_object);

<?php
function make_archive( $dir , &$zip, $extdir="")
{
       if (is_dir($dir)) {
           if ($dh = opendir($dir)) {
               while (($file = readdir($dh)) !== false ) {
                       if( $file != "." && $file != ".." )
                       {
                               if( is_dir( $dir . $file ) )
                               {

                                           $zip->add_file($dir.$file,$extdir.$file);

                                            make_archive($dir.$file."/" , $zip, $extdir.$file."/");

                               }
                               else
                               {
            
                                           $zip->add_file($dir.$file,$extdir.$file);                                                        
                               }
                       }
               }
               closedir($dh);
           }
       }
return true;
}
?>
10-May-2006 11:23
I try to use the function unpackZip from schore at NOSPAM dot hotmail dot com.

it appears that the fclose instruction is missing. Without that instruction, i've got some trouble to unpack zip file with recursive folders.

Here is the new code with the missing instruction
<?php
function unpackZip($dir,$file) {
   if ($zip = zip_open($dir.$file.".zip")) {
     if ($zip) {
       mkdir($dir.$file);
       while ($zip_entry = zip_read($zip)) {
         if (zip_entry_open($zip,$zip_entry,"r")) {
           $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
           $dir_name = dirname(zip_entry_name($zip_entry));
           if ($dir_name != ".") {
             $dir_op = $dir.$file."/";
               foreach ( explode("/",$dir_name) as $k) {
                 $dir_op = $dir_op . $k;
                 if (is_file($dir_op)) unlink($dir_op);
                 if (!is_dir($dir_op)) mkdir($dir_op);
                 $dir_op = $dir_op . "/" ;
                 }
               }
           $fp=fopen($dir.$file."/".zip_entry_name($zip_entry),"w");
           fwrite($fp,$buf);

           fclose($fp);

           zip_entry_close($zip_entry);
       } else
           return false;
       }
       zip_close($zip);
     }
  } else
     return false;

  return true;
}
?>
angelnsn1 at hotmail dot com
27-Jan-2006 11:06
this function extract all files and subdirectories, you can choose verbose mode for get paths of files extracted. the function return a msg what indicate the error, if msg is OK, all is done.

---

code:

function unzip($dir, $file, $verbose = 0) {

   $dir_path = "$dir$file";
   $zip_path = "$dir$file.zip";
  
   $ERROR_MSGS[0] = "OK";
   $ERROR_MSGS[1] = "Zip path $zip_path doesn't exists.";
   $ERROR_MSGS[2] = "Directory $dir_path for unzip the pack already exists, impossible continue.";
   $ERROR_MSGS[3] = "Error while opening the $zip_path file.";
  
   $ERROR = 0;
  
   if (file_exists($zip_path)) {
  
         if (!file_exists($dir_path)) {
            
            mkdir($dir_path);   
        
         if (($link = zip_open($zip_path))) {
            
            while (($zip_entry = zip_read($link)) && (!$ERROR)) {
               
               if (zip_entry_open($link, $zip_entry, "r")) {
          
                  $data = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                  $dir_name = dirname(zip_entry_name($zip_entry));
                  $name = zip_entry_name($zip_entry);
                 
                  if ($name[strlen($name)-1] == '/') {
                        
                        $base = "$dir_path/";

                     foreach ( explode("/", $name) as $k) {
                        
                        $base .= "$k/";
                           
                        if (!file_exists($base))
                           mkdir($base);
                           
                     }   
                       
                  }
                  else {
                 
                      $name = "$dir_path/$name";
                     
                      if ($verbose)
                       echo "extracting: $name<br>";
                       
                    $stream = fopen($name, "w");
                    fwrite($stream, $data);
                   
                  } 
                
                  zip_entry_close($zip_entry);
                
               }
               else
                  $ERROR = 4;    
 
              }
             
              zip_close($link); 
            
           }
           else
              $ERROR = "3";
       }
       else
          $ERROR = 2;
    }
    else
       $ERROR = 1;
     
   return $ERROR_MSGS[$ERROR];       
   
}   

---

example:

$error = unzip("d:/www/dir/", "zipname", 1);

echo $error;

---

i hope this help you,
good bye.
ringu at mail dot ru
20-Aug-2005 10:12
i try to find function that will show exists file in zip archive or not. of course i not found it. and so write mine:

first will just check archive for list of files, if not found all files function return FALSE:

function zipx_entries_exists()
{
    $names=array();
    $args=func_get_args();
    $far_size=count($args);   
    if($args[0])
        {           
            for(; $zip_entry=zip_read($args[0]); $names[]= zip_entry_name($zip_entry));                                   
            for($x=1; $x<=$far_size; $t+=in_array($args[$x], $names), $x++);           
            return $t==--$far_size;           
        }else{
             return 'No zip file in descriptor!';
        }              
}

example:
$zip=zip_open('any_zip_file_zip');
var_dump(zip_entries_exists($zip, 'photo_1.jpg', 'photo_2.jpg'));

second function will try to find files in zip, if not found it return string with names of not found files with specified delimeter:

function zipx_entries_nonexists_list()
{
    $names=array();
    $args=func_get_args();
    $m=NULL;
    $far_size=count($args);   
    if($args[0])
        {           
            for(; $zip_entry=zip_read($args[0]); $names[]= zip_entry_name($zip_entry));                                   
            for($x=2; $x<=$far_size; $m.=(in_array($args[$x], $names) ? NULL : $args[$x].$args[1]), $x++);           
            return trim($m, $args[1]);           
        }else{
             return 'No zip file in descriptor!';
        }              
}

example:
$zip=zip_open('any_zip_file_zip');
var_dump(zip_entries_nonexists_list($zip, '<br />', 'photo_1.jpg', 'photo_2.jpg'));

it will return if not found files:
photo_1.jpg<br />photo_2.jpg
tom
28-Jun-2005 01:33
If you just want to unzip a zip folder an alternative to some of the lengthy functions below is:

<?

function unzip($zip_file, $src_dir, $extract_dir)
{
 copy($src_dir . "/" . $zip_file, $extract_dir . "/" . $zip_file);
 chdir($extract_dir);
 shell_exec("unzip $zip_file");
}

?>

You don't need the ZIP extension for this.
candido1212 at yahoo dot com dot br
28-Apr-2005 12:52
New Unzip function, recursive extract
Require mkdirr() (recursive create dir)

$file = "2537c61ef7f47fc3ae919da08bcc1911.zip";
$dir = getcwd();
function Unzip($dir, $file, $destiny="")
{
    $dir .= DIRECTORY_SEPARATOR;
    $path_file = $dir . $file;
    $zip = zip_open($path_file);
    $_tmp = array();
    $count=0;
    if ($zip)
    {
        while ($zip_entry = zip_read($zip))
        {
            $_tmp[$count]["filename"] = zip_entry_name($zip_entry);
            $_tmp[$count]["stored_filename"] = zip_entry_name($zip_entry);
            $_tmp[$count]["size"] = zip_entry_filesize($zip_entry);
            $_tmp[$count]["compressed_size"] = zip_entry_compressedsize($zip_entry);
            $_tmp[$count]["mtime"] = "";
            $_tmp[$count]["comment"] = "";
            $_tmp[$count]["folder"] = dirname(zip_entry_name($zip_entry));
            $_tmp[$count]["index"] = $count;
            $_tmp[$count]["status"] = "ok";
            $_tmp[$count]["method"] = zip_entry_compressionmethod($zip_entry);
           
            if (zip_entry_open($zip, $zip_entry, "r"))
            {
                $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                if($destiny)
                {
                    $path_file = str_replace("/",DIRECTORY_SEPARATOR, $destiny . zip_entry_name($zip_entry));
                }
                else
                {
                    $path_file = str_replace("/",DIRECTORY_SEPARATOR, $dir . zip_entry_name($zip_entry));
                }
                $new_dir = dirname($path_file);
               
                // Create Recursive Directory
                mkdirr($new_dir);
               

                $fp = fopen($dir . zip_entry_name($zip_entry), "w");
                fwrite($fp, $buf);
                fclose($fp);

                zip_entry_close($zip_entry);
            }
            echo "\n</pre>";
            $count++;
        }

        zip_close($zip);
    }
}
Unzip($dir,$file);
Nahaylo Vitalik
25-Feb-2005 11:52
Zip Class from Devin Doucette at phpclasses.org
Allows the creation of tar, gzip, bzip2, and zip archives, and the extraction of tar, gzip, and bzip2.
Supports relative paths/no paths, comments, and recursing through subdirectories.
Can write file to disk, allow user to download directly, or return file contents in a string or an array.
Does not require any external programs to run.
Here is a link: http://www.phpclasses.org/browse/package/945.html
23-Feb-2005 01:54
If (as me) all you wanted to do is store a big string (for example, a serialized array or the like) in a mysql BLOB field, remember that mysql has a COMPRESS() and UNCOMPRESS() pair of functions that do exactly that. Compression/decompression is therefore available also when accessing the DB from other languages like java, etc.
Mishania AT ketsujin DOT COM
07-Jan-2005 01:19
I slightly changed the extension of Schore that makes function operate more effiecently - less number of itterations. This is most important in dealing with HUGE archives.  I also add comment to brief the code.  Fits for WIN users.
function unzip($dir,$file) {
  $zip = zip_open($dir.$file.".zip"))
  if ($zip) {
    mkdir($dir.$file);
    while ($zip_entry = zip_read($zip)) {
      if (zip_entry_open($zip,$zip_entry,"r")) {
        $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
        $hostDir = dirname(zip_entry_name($zip_entry));

              /*  for root "." directory nothing to be done coase root directory was
                  created before the while-loop statement */
        if ($hostDir != ".") {
          $absPathToHostDir = $dir.$file."\\";
         
              /* Convrerts path string upon to FMS & OS-WIN configuration */
          foreach ( explode("/",$hostDir) as $k)
            $absPathToHostDir = $absPathToHostDir . $k . "\\";
          $absPathToHostDir = substr($absPathToHostDir,0,-1);
          
          if (is_file($absPathToHostDir))
            unlink($absPathToHostDir);

          if (!is_dir($absPathToHostDir))
            mkdir($absPathToHostDir);

              /* Stores Archive entries BOTH as file: Directories & Files;
                 for this porpose we need these 2 hereabove [IF] checks  */
          $fp=fopen($dir.$file."\\".zip_entry_name($zip_entry),"w");
          fwrite($fp,$buf);
          fclose($fp);
          zip_entry_close($zip_entry);
 &nbsp