man zip Command

Man page for apt-get zip Command

Man Page for zip in Linux

Ubuntu Man Command : man zip

Man Zip  Command

This tutorial shows the man page for man zip in linux.

Open terminal with 'su' access and type the command as shown below:
man zip

Result of the Command Execution shown below:

ZIP(1)                                                                  ZIP(1)

zip package and compress (archive) files

zip [ aABcdDeEfFghjklLmoqrRSTuvVwXyz!@$] [ longoption ...] [ b path]
[ n suffixes] [ t date] [ tt date] [zipfile [file ...]] [ xi list]

zipcloak (see separate man page)

zipnote (see separate man page)

zipsplit (see separate man page)

Note: Command line processing in zip has been changed to support long
options and handle all options and arguments more consistently. Some
old command lines that depend on command line inconsistencies may no
longer work.

zip is a compression and file packaging utility for Unix, VMS, MSDOS,
OS/2, Windows 9x/NT/XP, Minix, Atari, Macintosh, Amiga, and Acorn RISC
OS. It is analogous to a combination of the Unix commands tar(1) and
compress(1) and is compatible with PKZIP (Phil Katz's ZIP for MSDOS

A companion program (unzip(1)) unpacks zip archives. The zip and
unzip(1) programs can work with archives produced by PKZIP (supporting
most PKZIP features up to PKZIP version 4.6), and PKZIP and PKUNZIP can
work with archives produced by zip (with some exceptions, notably
streamed archives, but recent changes in the zip file standard may
facilitate better compatibility). zip version 3.0 is compatible with
PKZIP 2.04 and also supports the Zip64 extensions of PKZIP 4.5 which
allow archives as well as files to exceed the previous 2 GB limit (4 GB
in some cases). zip also now supports bzip2 compression if the bzip2
library is included when zip is compiled. Note that PKUNZIP 1.10 can
not extract files produced by PKZIP 2.04 or zip 3.0. You must use PKUN
ZIP 2.04g or unzip 5.0p1 (or later versions) to extract them.

See the EXAMPLES section at the bottom of this page for examples of
some typical uses of zip.

Large Archives and Zip64. zip automatically uses the Zip64 extensions
when files larger than 4 GB are added to an archive, an archive con
taining Zip64 entries is updated (if the resulting archive still needs
Zip64), the size of the archive will exceed 4 GB, or when the number of
entries in the archive will exceed about 64K. Zip64 is also used for
archives streamed from standard input as the size of such archives are
not known in advance, but the option fz can be used to force zip to
create PKZIP 2 compatible archives (as long as Zip64 extensions are not
needed). You must use a PKZIP 4.5 compatible unzip, such as unzip 6.0
or later, to extract files using the Zip64 extensions.

In addition, streamed archives, entries encrypted with standard encryp
tion, or split archives created with the pause option may not be com
patible with PKZIP as data descriptors are used and PKZIP at the time
of this writing does not support data descriptors (but recent changes
in the PKWare published zip standard now include some support for the
data descriptor format zip uses).

Mac OS X. Though previous Mac versions had their own zip port, zip
supports Mac OS X as part of the Unix port and most Unix features
apply. References to "MacOS" below generally refer to MacOS versions
older than OS X. Support for some Mac OS features in the Unix Mac OS X
port, such as resource forks, is expected in the next zip release.

For a brief help on zip and unzip, run each without specifying any
parameters on the command line.

The program is useful for packaging a set of files for distribution;
for archiving files; and for saving disk space by temporarily compress
ing unused files or directories.

The zip program puts one or more compressed files into a single zip ar
chive, along with information about the files (name, path, date, time
of last modification, protection, and check information to verify file
integrity). An entire directory structure can be packed into a zip ar
chive with a single command. Compression ratios of 2:1 to 3:1 are com
mon for text files. zip has one compression method (deflation) and can
also store files without compression. (If bzip2 support is added, zip
can also compress using bzip2 compression, but such entries require a
reasonably modern unzip to decompress. When bzip2 compression is
selected, it replaces deflation as the default method.) zip automati
cally chooses the better of the two (deflation or store or, if bzip2 is
selected, bzip2 or store) for each file to be compressed.

Command format. The basic command format is

zip options archive inpath inpath ...

where archive is a new or existing zip archive and inpath is a direc
tory or file path optionally including wildcards. When given the name
of an existing zip archive, zip will replace identically named entries
in the zip archive (matching the relative names as stored in the ar
chive) or add entries for new names. For example, if exists
and contains foo/file1 and foo/file2, and the directory foo contains
the files foo/file1 and foo/file3, then:

zip r foo

or more concisely

zip r foo foo

will replace foo/file1 in and add foo/file3 to After
this, contains foo/file1, foo/file2, and foo/file3, with
foo/file2 unchanged from before.

So if before the zip command is executed has:

foo/file1 foo/file2

and directory foo has:

file1 file3

then will have:

foo/file1 foo/file2 foo/file3

where foo/file1 is replaced and foo/file3 is new.

@ file lists. If a file list is specified as @ [Not on MacOS], zip
takes the list of input files from standard input instead of from the
command line. For example,

zip @ foo

will store the files listed one per line on stdin in

Under Unix, this option can be used to powerful effect in conjunction
with the find (1) command. For example, to archive all the C source
files in the current directory and its subdirectories:

find . name "*.[ch]" print | zip source @

(note that the pattern must be quoted to keep the shell from expanding

Streaming input and output. zip will also accept a single dash (" ")
as the zip file name, in which case it will write the zip file to stan
dard output, allowing the output to be piped to another program. For

zip r . | dd of=/dev/nrst0 obs=16k

would write the zip output directly to a tape with the specified block
size for the purpose of backing up the current directory.

zip also accepts a single dash (" ") as the name of a file to be com
pressed, in which case it will read the file from standard input,
allowing zip to take input from another program. For example:

tar cf . | zip backup

would compress the output of the tar command for the purpose of backing
up the current directory. This generally produces better compression
than the previous example using the r option because zip can take
advantage of redundancy between files. The backup can be restored using
the command

unzip p backup | tar xf

When no zip file name is given and stdout is not a terminal, zip acts
as a filter, compressing standard input to standard output. For exam

tar cf . | zip | dd of=/dev/nrst0 obs=16k

is equivalent to

tar cf . | zip | dd of=/dev/nrst0 obs=16k

zip archives created in this manner can be extracted with the program
funzip which is provided in the unzip package, or by gunzip which is
provided in the gzip package (but some gunzip may not support this if
zip used the Zip64 extensions). For example:

dd if=/dev/nrst0 ibs=16k | funzip | tar xvf

The stream can also be saved to a file and unzip used.

If Zip64 support for large files and archives is enabled and zip is
used as a filter, zip creates a Zip64 archive that requires a PKZIP 4.5
or later compatible unzip to read it. This is to avoid amgibuities in
the zip file structure as defined in the current zip standard (PKWARE
AppNote) where the decision to use Zip64 needs to be made before data
is written for the entry, but for a stream the size of the data is not
known at that point. If the data is known to be smaller than 4 GB, the
option fz can be used to prevent use of Zip64, but zip will exit with
an error if Zip64 was in fact needed. zip 3 and unzip 6 and later can
read archives with Zip64 entries. Also, zip removes the Zip64 exten
sions if not needed when archive entries are copied (see the U
( copy) option).

When directing the output to another file, note that all options should
be before the redirection including x. For example:

zip archive "*.h" "*.c" x donotinclude.h orthis.h > tofile

Zip files. When changing an existing zip archive, zip will write a
temporary file with the new contents, and only replace the old one when
the process of creating the new version has been completed without

If the name of the zip archive does not contain an extension, the
extension .zip is added. If the name already contains an extension
other than .zip, the existing extension is kept unchanged. However,
split archives (archives split over multiple files) require the .zip
extension on the last split.

Scanning and reading files. When zip starts, it scans for files to
process (if needed). If this scan takes longer than about 5 seconds,
zip will display a "Scanning files" message and start displaying
progress dots every 2 seconds or every so many entries processed,
whichever takes longer. If there is more than 2 seconds between dots
it could indicate that finding each file is taking time and could mean
a slow network connection for example. (Actually the initial file scan
is a two step process where the directory scan is followed by a sort
and these two steps are separated with a space in the dots. If updat
ing an existing archive, a space also appears between the existing file
scan and the new file scan.) The scanning files dots are not con
trolled by the ds dot size option, but the dots are turned off by the
q quiet option. The sf show files option can be used to scan for
files and get the list of files scanned without actually processing

If zip is not able to read a file, it issues a warning but continues.
See the MM option below for more on how zip handles patterns that are
not matched and files that are not readable. If some files were
skipped, a warning is issued at the end of the zip operation noting how
many files were read and how many skipped.

Command modes. zip now supports two distinct types of command modes,
external and internal. The external modes (add, update, and freshen)
read files from the file system (as well as from an existing archive)
while the internal modes (delete and copy) operate exclusively on
entries in an existing archive.

Update existing entries and add new files. If the archive does
not exist create it. This is the default mode.

update ( u)
Update existing entries if newer on the file system and add new
files. If the archive does not exist issue warning then create
a new archive.

freshen ( f)
Update existing entries of an archive if newer on the file sys
tem. Does not add new files to the archive.

delete ( d)
Select entries in an existing archive and delete them.

copy ( U)
Select entries in an existing archive and copy them to a new ar
chive. This new mode is similar to update but command line pat
terns select entries in the existing archive rather than files
from the file system and it uses the out option to write the
resulting archive to a new file rather than update the existing
archive, leaving the original archive unchanged.

The new File Sync option ( FS) is also considered a new mode, though it
is similar to update. This mode synchronizes the archive with the
files on the OS, only replacing files in the archive if the file time
or size of the OS file is different, adding new files, and deleting
entries from the archive where there is no matching file. As this mode
can delete entries from the archive, consider making a backup copy of
the archive.

Also see DF for creating difference archives.

See each option description below for details and the EXAMPLES section
below for examples.

Split archives. zip version 3.0 and later can create split archives.
A split archive is a standard zip archive split over multiple files.
(Note that split archives are not just archives split in to pieces, as
the offsets of entries are now based on the start of each split. Con
catenating the pieces together will invalidate these offsets, but unzip
can usually deal with it. zip will usually refuse to process such a
spliced archive unless the FF fix option is used to fix the offsets.)

One use of split archives is storing a large archive on multiple remov
able media. For a split archive with 20 split files the files are typ
ically named (replace ARCHIVE with the name of your archive) AR
CHIVE.z01, ARCHIVE.z02, ..., ARCHIVE.z19, Note that the
last file is the .zip file. In contrast, spanned archives are the
original multi disk archive generally requiring floppy disks and using
volume labels to store disk numbers. zip supports split archives but
not spanned archives, though a procedure exists for converting split
archives of the right size to spanned archives. The reverse is also
true, where each file of a spanned archive can be copied in order to
files with the above names to create a split archive.

Use s to set the split size and create a split archive. The size is
given as a number followed optionally by one of k (kB), m (MB), g (GB),
or t (TB) (the default is m). The sp option can be used to pause zip
between splits to allow changing removable media, for example, but read
the descriptions and warnings for both s and sp below.

Though zip does not update split archives, zip provides the new option
O ( output file or out) to allow split archives to be updated and
saved in a new archive. For example,

zip foo.c bar.c out

reads archive, even if split, adds the files foo.c and
bar.c, and writes the resulting archive to If inar is split then defaults to the same split size.
Be aware that if and any split files that are created
with it already exist, these are always overwritten as needed without
warning. This may be changed in the future.

Unicode. Though the zip standard requires storing paths in an archive
using a specific character set, in practice zips have stored paths in
archives in whatever the local character set is. This creates problems
when an archive is created or updated on a system using one character
set and then extracted on another system using a different character
set. When compiled with Unicode support enabled on platforms that sup
port wide characters, zip now stores, in addition to the standard local
path for backward compatibility, the UTF 8 translation of the path.
This provides a common universal character set for storing paths that
allows these paths to be fully extracted on other systems that support
Unicode and to match as close as possible on systems that don't.

On Win32 systems where paths are internally stored as Unicode but rep
resented in the local character set, it's possible that some paths will
be skipped during a local character set directory scan. zip with Uni
code support now can read and store these paths. Note that Win 9x sys
tems and FAT file systems don't fully support Unicode.

Be aware that console windows on Win32 and Unix, for example, sometimes
don't accurately show all characters due to how each operating system
switches in character sets for display. However, directory navigation
tools should show the correct paths if the needed fonts are loaded.

Command line format. This version of zip has updated command line pro
cessing and support for long options.

Short options take the form

s[ ][s[ ]...][value][=value][ value]

where s is a one or two character short option. A short option that
takes a value is last in an argument and anything after it is taken as
the value. If the option can be negated and " " immediately follows
the option, the option is negated. Short options can also be given as
separate arguments

s[ ][value][=value][ value] s[ ][value][=value][ value] ...

Short options in general take values either as part of the same argu
ment or as the following argument. An optional = is also supported.





tt mmddyyyy

all work. The x and i options accept lists of values and use a
slightly different format described below. See the x and i options.

Long options take the form

longoption[ ][=value][ value]

where the option starts with , has a multicharacter name, can include
a trailing dash to negate the option (if the option supports it), and
can have a value (option argument) specified by preceding it with = (no
spaces). Values can also follow the argument. So

before date=mmddyyyy


before date mmddyyyy

both work.

Long option names can be shortened to the shortest unique abbreviation.
See the option descriptions below for which support long options. To
avoid confusion, avoid abbreviating a negatable option with an embedded
dash (" ") at the dash if you plan to negate it (the parser would con
sider a trailing dash, such as for the option some option using
some as the option, as part of the name rather than a negating
dash). This may be changed to force the last dash in some to be
negating in the future.

[Systems using EBCDIC] Translate file to ASCII format.

adjust sfx
Adjust self extracting executable archive. A self extracting
executable archive is created by prepending the SFX stub to an
existing archive. The A option tells zip to adjust the entry
offsets stored in the archive to take into account this "pream
ble" data.

Note: self extracting archives for the Amiga are a special case. At
present, only the Amiga port of zip is capable of adjusting or updating
these without corrupting them. J can be used to remove the SFX stub if
other updates need to be made.

archive clear
[WIN32] Once archive is created (and tested if T is used,
which is recommended), clear the archive bits of files pro
cessed. WARNING: Once the bits are cleared they are cleared.
You may want to use the sf show files option to store the list
of files processed in case the archive operation must be
repeated. Also consider using the MM must match option. Be
sure to check out DF as a possibly better way to do incremental

archive set
[WIN32] Only include files that have the archive bit set.
Directories are not stored when AS is used, though by default
the paths of entries, including directories, are stored as usual
and can be used by most unzips to recreate directories.

The archive bit is set by the operating system when a file is
modified and, if used with AC, AS can provide an incremental
backup capability. However, other applications can modify the
archive bit and it may not be a reliable indicator of which
files have changed since the last archive operation. Alterna
tive ways to create incremental backups are using t to use file
dates, though this won't catch old files copied to directories
being archived, and DF to create a differential archive.

[VM/CMS and MVS] force file to be read binary (default is text).

Bn [TANDEM] set Edit/Enscribe formatting options with n defined as
bit 0: Don't add delimiter (Edit/Enscribe)
bit 1: Use LF rather than CR/LF as delimiter (Edit/Enscribe)
bit 2: Space fill record to maximum record length (Enscribe)
bit 3: Trim trailing space (Enscribe)
bit 8: Force 30K (Expand) large read for unstructured files

b path
temp path path
Use the specified path for the temporary zip archive. For exam

zip b /tmp stuff *

will put the temporary zip archive in the directory /tmp, copy
ing over to the current directory when done. This
option is useful when updating an existing archive and the file
system containing this old archive does not have enough space to
hold both old and new archives at the same time. It may also be
useful when streaming in some cases to avoid the need for data
descriptors. Note that using this option may require zip take
additional time to copy the archive file when done to the desti
nation file system.

entry comments
Add one line comments for each file. File operations (adding,
updating) are done first, and the user is then prompted for a
one line comment for each file. Enter the comment followed by
return, or just return for no comment.

preserve case
[VMS] Preserve case all on VMS. Negating this option ( C )

preserve case 2
[VMS] Preserve case ODS2 on VMS. Negating this option ( C2 )

preserve case 5
[VMS] Preserve case ODS5 on VMS. Negating this option ( C5 )

Remove (delete) entries from a zip archive. For example:

zip d foo foo/tom/junk foo/harry/\* \*.o

will remove the entry foo/tom/junk, all of the files that start
with foo/harry/, and all of the files that end with .o (in any
path). Note that shell pathname expansion has been inhibited
with backslashes, so that zip can see the asterisks, enabling
zip to match on the contents of the zip archive instead of the
contents of the current directory. (The backslashes are not
used on MSDOS based platforms.) Can also use quotes to escape
the asterisks as in

zip d foo foo/tom/junk "foo/harry/*" "*.o"

Not escaping the asterisks on a system where the shell expands
wildcards could result in the asterisks being converted to a
list of files in the current directory and that list used to
delete entries from the archive.

Under MSDOS, d is case sensitive when it matches names in the
zip archive. This requires that file names be entered in upper
case if they were zipped by PKZIP on an MSDOS system. (We con
sidered making this case insensitive on systems where paths were
case insensitive, but it is possible the archive came from a
system where case does matter and the archive could include both
Bar and bar as separate files in the archive.) But see the new
option ic to ignore case in the archive.

display bytes
Display running byte counts showing the bytes zipped and the
bytes to go.

display counts
Display running count of entries zipped and entries to go.

display dots
Display dots while each entry is zipped (except on ports that
have their own progress indicator). See ds below for setting
dot size. The default is a dot every 10 MB of input file pro
cessed. The v option also displays dots (previously at a much
higher rate than this but now v also defaults to 10 MB) and
this rate is also controlled by ds.

[MacOS] Include only data fork of files zipped into the archive.
Good for exporting files to foreign operating systems.
Resource forks will be ignored at all.

display globaldots
Display progress dots for the archive instead of for each file.
The command

zip qdgds 10m

will turn off most output except dots every 10 MB.

ds size
dot size size
Set amount of input file processed for each dot displayed. See
dd to enable displaying dots. Setting this option implies dd.
Size is in the format nm where n is a number and m is a multi
plier. Currently m can be k (KB), m (MB), g (GB), or t (TB), so
if n is 100 and m is k, size would be 100k which is 100 KB. The
default is 10 MB.

The v option also displays dots and now defaults to 10 MB also.
This rate is also controlled by this option. A size of 0 turns
dots off.

This option does not control the dots from the "Scanning files"
message as zip scans for input files. The dot size for that is
fixed at 2 seconds or a fixed number of entries, whichever is

display usize
Display the uncompressed size of each entry.

display volume
Display the volume (disk) number each entry is being read from,
if reading an existing archive, and being written to.

no dir entries
Do not create entries in the zip archive for directories.
Directory entries are created by default so that their
attributes can be saved in the zip archive. The environment
variable ZIPOPT can be used to change the default options. For
example under Unix with sh:

ZIPOPT=" D"; export ZIPOPT

(The variable ZIPOPT can be used for any option, including i
and x using a new option format detailed below, and can include
several options.) The option D is a shorthand for x "*/" but
the latter previously could not be set as default in the ZIPOPT
environment variable as the contents of ZIPOPT gets inserted
near the beginning of the command line and the file list had to
end at the end of the line.

This version of zip does allow x and i options in ZIPOPT if
the form

x file file ... @

is used, where the @ (an argument that is just @) terminates the

difference archive
Create an archive that contains all new and changed files since
the original archive was created. For this to work, the input
file list and current directory must be the same as during the
original zip operation.

For example, if the existing archive was created using

zip r foofull .

from the bar directory, then the command

zip r foofull . DF out foonew

also from the bar directory creates the archive foonew with just
the files not in foofull and the files where the size or file
time of the files do not match those in foofull.

Note that the timezone environment variable TZ should be set
according to the local timezone in order for this option to work
correctly. A change in timezone since the original archive was
created could result in no times matching and all files being

A possible approach to backing up a directory might be to create
a normal archive of the contents of the directory as a full
backup, then use this option to create incremental backups.

Encrypt the contents of the zip archive using a password which
is entered on the terminal in response to a prompt (this will
not be echoed; if standard error is not a tty, zip will exit
with an error). The password prompt is repeated to save the
user from typing errors.

[OS/2] Use the .LONGNAME Extended Attribute (if found) as file

Replace (freshen) an existing entry in the zip archive only if
it has been modified more recently than the version already in
the zip archive; unlike the update option ( u) this will not add
files that are not already in the zip archive. For example:

zip f foo

This command should be run from the same directory from which
the original zip command was run, since paths stored in zip ar
chives are always relative.

Note that the timezone environment variable TZ should be set
according to the local timezone in order for the f, u and o
options to work correctly.

The reasons behind this are somewhat subtle but have to do with
the differences between the Unix format file times (always in
GMT) and most of the other operating systems (

Related Topics

Apt Get Commands