ZIP(1)                          General Commands Manual                          ZIP(1)

NÉV
       zip, zipnote, zipsplit - (archívum) fájlok csomagolása és tömörítése

ÁTTEKINTÉS
       zip  [-AcdDeEfFghjklLmoqrSTuvVwXyz@$] [-b útvonal] [-n végződések] [-t hhnnéé] [
       zipfile [ file1 file2 ...]] [-xi lista]

       zipcloak [-dhL] [-b útvonal] zipfile

       zipnote [-hwL] [-b útvonal] zipfile

       zipsplit [-hiLpst] [-n méret] [-b útvonal] zipfile

LEÍRÁS
       A zip egy tömörítő és file csomagoló program Unix, VMS, MSDOS, OS/2, Windows NT,
       Minix, Atari és Macintosh rendszerekre.  Hasonlít a tar(1) és a compress(1) UNIX
       parancsok kombinációjához és kompatíbilis a PKZIP-pel (Phil Katz  ZIP  programja
       MSDOS rendszerre).

       A  zip-et kiegészítő unzip(1) program kicsomagolja a zip archívumokat.  A zip és
       az  unzip(1)  programok  tudják  kezelni  a  PKZIP-pel  készített  archívumokat,
       valamint a PKZIP és a PKUNZIP is tudja kezelni a zip-pel készített archívumokat.
       A zip 2.1-es verziója kompatíbilis a PKZIP 2.04-gyel.  Figyelem: a PKUNZIP  1.10
       nem  tudja  kicsomagolni  a  PKZIP  2.04-gyel vagy a zip-pel készített fájlokat.
       Ehhez a PKUNZIP 2.04g-t vagy az unzip 5.0p1-et  (vagy  későbbi  verziókat)  kell
       használni.

       Ha  a zip és az unzip programokat paraméterek nélkül indítjuk, egy rövid leírást
       adnak a használatukról.

       A program segítségével becsomagolhatunk fájlokat  terjesztéshez,  archiváláshoz,
       és   a   nem   használt  fájlok  vagy  könyvtárak  tömörítésével  lemezterületet
       takaríthatunk meg.

       A zip egy vagy több fájlt egyetlen  zip  archívumba  tesz  a  fájlokhoz  tartozó
       információval  együtt.  (Név, útvonal, dátum, utolsó módosítás ideje, védelem és
       információ a  file  sértetlenségének  ellenőrzésére.)   Egy  teljes  alkönyvtár-
       szerkezet  egyetlen  paranccsal  becsomagolható egy zip archívumba.  Szövegfile-
       oknál általános a 2:1 és 3:1 közötti tömörítési arány. A zip egyféle  tömörítési
       módszert  ismer  (deflation)  és a fájlokat tömörítés nélkül is tudja tárolni. A
       zip minden tömörítendő fájlra automatikusan kiválasztja a kettő közül a jobbat.

       Ha egy már létező zip archívum nevét adjuk meg, akkor az azonos nevű fájlokat  a
       zip  lecseréli  az  archívumban,  az  új  fájlokat pedig felveszi.  Például ha a
       valami.zip már létezik, és tartalmazza a valami/file1,  valami/file2  file-okat,
       és a valami könyvtár tartalmazza a valami/file1, valami/file3 file-okat, akkor a

              zip -r valami valami

       parancs  lecseréli  a  valami.zip-ben  a  valami/file1  file-t,  és  hozzáadja a
       valami.zip-hez a valami/file3 file-t.  Ezután a valami.zip tartalmazni  fogja  a
       valami/file1,  valami/file2,  és valami/file3 file-okat úgy, hogy a valami/file2
       változatlan marad.

       Ha a file listát -@ alakban adjuk meg, akkor a zip a szabványos bemenetről várja
       az  input  fájlok listáját.  UNIX alatt ez a lehetőség nagyon jól kihasználható,
       ha a find(1) paranccsal együtt használjuk.  Ha például  minden  C  forrás  fájlt
       archiválni  akarunk  az aktuális könyvtárból és minden alkönyvtárából, akkor ezt
       írjuk:

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

       (Figyeljük  meg,  hogy  a  mintát   idézőjelek   közé   kell   tenni,   hogy   a
       parancsértelmező  ne tudja kiterjeszteni.)  A zip a zip file nevének elfogad egy
       kötőjelet ("-") is, ebben az esetben a zip file-t a szabványos  kimenetre  fogja
       írni, így a kimenetet egy másik programnak adhatjuk tovább. Például a

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

       parancs  úgy  csinál  mentést  az  aktuális  könyvtárról,  hogy  a zip kimenetét
       közvetlenül szalagra írja a megadott blokkmérettel.

       A zip a tömörítendő file neveként  elfogad  egy  kötőjelet  ("-")  is,  ekkor  a
       standard  bemenetről  fogja beolvasni a fájlt, lehetővé téve, hogy a bemenet egy
       másik programtól érkezzen. Például a

              tar cf - . | zip backup -

       parancs úgy csinál mentést az aktuális könyvtárról, hogy a tar program kimenetét
       tömöríti be. Ez általában jobb tömörítést ad, mint az előző példában használt -r
       kapcsoló, mert a zip így ki tudja használni  a  fájlok  közti  redundanciát.   A
       mentést visszatölthetjük az

              unzip -p backup | tar xf -

       paranccsal.   Ha  nem  adunk  meg zip file nevet és a szabványos kimenet nem egy
       terminál, akkor a zip szűrőként működve tömörítve írja ki a szabványos kimenetre
       a szabványos bemenet tartalmát. Például a

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

       parancs megfelel a

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

       parancsnak.  Az  így  készített  zip  archívumok kicsomagolhatók az unzip csomag
       funzip programjával, vagy a gzip csomag gunzip programjával. Például:

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

       Amikor a zip egy már létező zip archívumot módosít, egy ideiglenes  fájlba  írja
       az  új  tartalmat,  és csak akkor cseréli le az eredeti fájlt, ha az új változat
       létrehozása hibátlanul sikerült.

       Ha a zip archívum neve nem tartalmaz kiterjesztést, akkor a  .zip  kiterjesztést
       fogja  használni.  Ha  a  név  már tartalmaz a .zip-től különböző kiterjesztést,
       akkor a meglévő kiterjesztés nem változik.

OPCIÓK
       -A     Önkicsomagoló archívum igazítása.  Az önkicsomagoló archívum  egy  létező
              archívumból  jön  létre  úgy, hogy az elejére egy SFX blokk kerül.  Az -A
              opció  jelzi  a  zip-nek,  hogy   ennek   a   bevezető   adatblokknak   a
              figyelembevételével igazítsa a tábla-bejegyzések eltolási értékeit.

       -b elérési út
              A   megadott   elérési   út   használata   az   ideiglenes  zip  archívum
              létrehozásához. Például a

                     zip -b /tmp cucc *

              parancs a /tmp könyvtárba fogja tenni az ideiglenes zip archívumot,  amit
              majd  az  aktuális  könyvtárban  levő cucc.zip file-ba másol. Ez az opció
              akkor hasznos, ha egy már létező archívumot frissítünk, és az  archívumot
              tartalmazó fájlrendszeren nincs elég szabad hely ahhoz, hogy a régi és az
              új archívum egyszerre elférjen.

       -c     Egysoros megjegyzések hozzáadása minden fájlhoz.  Először a fájlműveletek
              (hozzáadás,  frissítés)  hajtódnak  végre,  ezután  a  felhasználó minden
              fájlhoz megadhat egy egysoros megjegyzést.  Minden  fájlhoz  írjuk  be  a
              megjegyzést  enterrel  lezárva, vagy üssünk csak entert, ahol nem akarunk
              megjegyzést megadni.

       -d     File-ok eltávolítása (törlése) a zip archívumból.  Például a

                     zip -d valami valami/pista/szemet valami/jancsi/\* \*.o

              parancs    eltávolítja    a    valami/pista/szemet     file-t,     minden
              valami/jancsi/-val   kezdődő   fájlt,  és  minden  .o-val  végződő  fájlt
              (bármilyen elérési útra).  Figyeljük meg, hogy a "\" karakterrel kerültük
              el,  hogy a parancsértelmező automatikusan kiterjessze az elérési utakat,
              így a zip látni fogja a csillagokat, és  a  megadott  elérési  utakat  az
              archívum tartalmára értelmezi, nem pedig az aktuális könyvtárra.

              MSDOS  alatt  a  -d  opció  különbséget  tesz a kis- és nagybetűk között,
              amikor a zip archívumban levő fájlokat keresi.  Ezért a fájlneveket csupa
              nagybetűvel kell megadni, ha MSDOS rendszeren a PKZIP-pel zippeltük őket.

       -D     Az   alkönyvtáraknak   ne   legyen   bejegyzésük   a   zip   archívumban.
              Alapértelmezés szerint az alkönyvtárakhoz is  készül  bejegyzés,  így  az
              attribútumaik megőrződnek a zip archívumban.  A ZIPOPT környezeti változó
              használatával megváltoztathatjuk  az  alapértelmezés  szerinti  opciókat.
              Például Unix alatt sh-ban:

                     ZIPOPT="-D"; export ZIPOPT

              (A ZIPOPT változó bármilyen opciót tartalmazhat -- egyszerre többet is --
              kivéve a -i és a -x opciókat. A -D a -x "*/" rövidítése, de ez utóbbi nem
              állítható be a ZIPOPT környezeti változóval.

       -e     A zip archívum tartalmának titkosítása. A terminálon bekér egy jelszót (a
              jelszó nem fog látszani a beíráskor; ha a szabványos hibakimenet nem  tty
              eszköz,  akkor  a  zip  hibaüzenettel leáll).  A jelszót kétszer kéri be,
              hogy a felhasználót megvédje a gépelési hibáktól.

       -f     Csak akkor cserél (frissít) egy fájlt  a  zip  archívumban,  ha  a  fájlt
              újabban   módosították,  mint  a  zip  archívumban  levő  változatát.   A
              frissítés (-u) opcióval ellentétben ezzel nem kerülnek be új fájlok a zip
              archívumba.  Például:

                     zip -f valami

              Ezt  a  parancsot  abból  a  könyvtárból kell kiadni, ahol az eredeti zip
              parancsot is kiadtuk, hiszen a  zip  archívumokban  tárolt  elérési  utak
              mindig relatívak.

              Megjegyzés:  A  TZ  (időzóna)  környezeti  változót  a  helyi  időzónának
              megfelelően kell beállítani ahhoz, hogy a -f , -u , és -o opciók helyesen
              működjenek.

              Ennek az okai eléggé szövevényesek, körülbelül arról van szó, hogy a Unix
              fájlmódosítási idő formátuma (mindig  GMT)  különbözik  a  legtöbb  egyéb
              operációs  rendszerétől  (mindig  helyi  idő),  és  a  kettőt  össze kell
              hasonlítani.  Egy  tipikus  TZ  érték  például:  ``MET-1METDST''  (Közép-
              európai idő a nyári-téli időszámítás automatikus állításával).

       -F     A  zip archívum kijavítása. Ez az opció akkor használható, ha az archívum
              egyes részei hiányoznak. Nincs garancia arra, hogy működik, ezért először
              MINDENKÉPPEN csináljunk egy biztonsági másolatot az eredeti archívumról!

              Ha  duplán  adjuk  meg  (-FF), akkor a zip nem bízik a sérült archívumban
              tárolt fájlméretekben, és  jellegzetes  mintázatok  keresésével  próbálja
              azonosítani  a  fájlok  közti  határokat  az  archívumban.   A szimpla -F
              megbízhatóbb, ha az archívum nem sérült meg nagyon,  például  ha  csak  a
              vége hiányzik; ezért először ezt az opciót használjuk.

              Egyik  opció  sem tudja helyrehozni az archívumot, ha azt bináris helyett
              ascii módban továbbították. A javítás után az  unzip  -t  opciója  néhány
              fájlnál hibás CRC-t jelezhet. Az ilyen fájlokat nem lehet helyreállítani;
              törölhetők az archívumból a zip -d opciójával.

       -g     A fájlokat hozzáadja a megadott archívumhoz, ahelyett, hogy új archívumot
              hozna   létre.    Ha   ez  a  művelet  nem  sikerül,  a  zip  megpróbálja
              visszaállítani az archívum eredeti  állapotát.  Ha  a  visszaállítás  nem
              sikerül, az archívum megsérülhet.

       -h     Segítséget  ad a zip használatához. (Ez jelenik meg akkor is, ha a zip-et
              argumentumok nélkül indítjuk.)

       -i fájlok
              Csak a megadott fájlokat vegye fel, például:

                     zip -r valami . -i \*.c

              Ez csak azokat a fájlokat csomagolja az  aktuális  könyvtárból  és  annak
              alkönyvtáraiból,    amelyek     .c-re    végződnek.   (Megjegyzés   PKZIP
              felhasználóknak: az ezzel ekvivalens parancs a

                     pkzip -rP valami *.c

              A PKZIP csak az aktuális könyvtárban engedi  meg  a  rekurziót.)   A  "\"
              karakterrel   elkerüljük,   hogy  a  parancsértelmező  behelyettesítse  a
              fájlneveket, így a fájlok keresését minden alkönyvtár-szinten a zip fogja
              végezni.

       -j     Csak  a  fájlneveket tárolja (az elérési utat elhagyja), és nem tárolja a
              könyvtárak neveit. Alapértelmezés szerint a zip  a  teljes  elérési  utat
              tárolja (az aktuális könyvtártól számítva).

       -J     Levágja  az  archívum elejére illesztett bármilyen kiegészítő adatblokkot
              (pl. SFX blokk az önkicsomagoló archívumoknál).

       -k     Megpróbálja az MSDOS-nak  megfelelő  formába  konvertálni  a  neveket  és
              elérési utakat, csak az MSDOS fájlattribútumokat tárolja (UNIX alatt csak
              a felhasználó írási jogát), és úgy jegyzi be a fájlokat, mint MSDOS alatt
              készített  bejegyzések  (akkor  is, ha ez nem igaz). Ez az opció az MSDOS
              alatti PKZIP-pel való kompatibilitás megőrzésére szolgál,  mivel  az  nem
              tud  kezelni  bizonyos  fájlneveket,  például  azokat, amelyek két pontot
              tartalmaznak.

       -l     A Unix sorvége jeleit (LF) lecseréli az MSDOS konvenciójának megfelelő CR
              LF-re.  Ezt  az  opciót  ne  használjuk  bináris fájlokra!  Unix alatt is
              használhatjuk, ha a zip fájlt MSDOS-ra  a  PKUNZIP-nak  szánjuk.   Ha  az
              input  fájlokban  már CR LF karakterek vannak, akkor ez az opció plusz CR
              karaktereket fog hozzáadni. Ezáltal az unzip -a  Unix  alatt  az  eredeti
              file pontos másolatát adja, és visszavonja a zip -l hatását.

       -ll    Az  MSDOS  sorvége  jeleit  (CR LF) lecseréli a Unix-nak megfelelő LF-re.
              Ezt  az  opciót  ne  használjuk  bináris   fájlokra!   MSDOS   alatt   is
              használhatjuk, ha a zip fájlt Unix-ra az unzip-nak szánjuk.

       -L     A zip licensz megjelenítése.

       -m     A   megadott   fájlokat  áthelyezi  a  zip  archívumba,  vagyis  törli  a
              könyvtárakat és a fájlokat, miután létrehozta a megadott zip  archívumot.
              Ha  egy  könyvtár  a benne lévő fájlok törlése után üressé válik, akkor a
              könyvtárat is törli. A zip addig nem töröl  semmit,  amíg  az  archívumot
              hibátlanul   létre  nem  hozta.   Ez  az  opció  hasznos  a  lemezterület
              megtakarítására, de potenciálisan veszélyes, ezért ajánlott a -T opcióval
              együtt használni, ami a fájlok törlése előtt ellenőrzi az archívumot.

       -n végződések
              Nem  próbálja meg tömöríteni azokat a fájlokat, amelyek neve a végződések
              valamelyikére végződik.  Az ilyen fájlokat a zip egyszerűen eltárolja (0%
              tömörítés)  a  zip  fájlban,  így nem pazarol időt arra, hogy megpróbálja
              tömöríteni őket.  A végződéseket vagy kettősponttal vagy  pontosvesszővel
              kell elválasztani egymástól.  Például:

                     zip -rn .Z:.zip:.tiff:.gif:.snd  valami valami

              Ez  a parancs a valami-ből mindent bemásol a valami.zip-be, de minden .Z,
              .zip, .tiff,  .gif,  vagy  .snd  végződésű  fájlt  tömörítés  nélkül  fog
              tárolni.  (A kép- és hangfile-oknak általában megvannak a saját speciális
              tömörítési módszereik.)  A zip alapértelmezés szerint nem tömöríti azokat
              a  fájlokat, amelyek neve a .Z:.zip:.zoo:.arc:.lzh:.arj listában szereplő
              végződések valamelyikére végződik.  Az ilyen fájlokat közvetlenül tárolja
              az  archívumban.   A ZIPOPT környezeti változó segítségével beállíthatjuk
              az alapértelmezés szerinti opciókat. Példaul Unix-ban csh-val:

                     setenv ZIPOPT "-n .gif:.zip"

              Ha minden fájlt meg akarunk próbálni tömöríteni:

                     zip -n : valami

              A zip a  maximális  tömörítést  jelző  -9  opció  hatására  is  megpróbál
              tömöríteni minden fájlt a végződésektől függetlenül.

       -o     A  zip  archívum  "utolsó  módosítás"  idejét  beállítja  a  zip archívum
              bejegyzései  között  talált  legutolsó  (legrégebbi)  "utolsó  módosítás"
              idejére.  Ez használható önmagában is, minden más művelet nélkül. Például
              a

              zip -o valami

              parancs beállítja a valami.zip "utolsó módosítás"  idejét  a  bejegyzései
              közti legutolsó időre.

       -q     Csendes   mód:   nem   ír   ki  tájékoztató  üzeneteket  és  nem  kér  be
              megjegyzéseket.  (Hasznos például shell  scriptekben  és  háttérben  futó
              task-nál.)

       -r     A könyvtárszerkezet rekurzív bejárása; például:

                     zip -r valami valami

              Ebben az esetben a valami-ben levő összes fájlt és alkönyvtárat elmenti a
              valami.zip nevű zip archívumba; beleértve a "."-tal kezdődő nevű fájlokat
              is,   hiszen   a   rekurzió  nem  használja  a  parancsértelmező  fájlnév
              helyettesítő mechanizmusát.  Ha a valami alkönyvtárban levő fájloknak  és
              alkönyvtáraknak  csak  egy adott részhalmazát akarjuk menteni, akkor a -i
              opcióval adhatjuk meg a kívánt fájlnév mintát.  A -r opciót nem  tanácsos
              a  ".*"  fájlnévvel  használni, mert ez ráillik a ".."-ra is, így a szülő
              könyvtárat is becsomagolja (és valószínűleg nem ezt akartuk).

       -S     Felveszi a rendszer- és a rejtett fájlokat is. Ez az  opció  csak  néhány
              rendszeren működik, Unix-on nincs hatása.

       -t mmddyy
              Kihagyja  azokat  a  fájlokat,  amelyek utolsó módosítási ideje korábbi a
              megadott dátumnál, ahol mm a hónap (0-12), dd a hónap napja (1-31), és yy
              az évszám utolsó két számjegye.  Például a

                     zip -rt 120791 infamy valami

              parancs  hozzáadja  az infamy.zip archívumhoz a valami alkönyvtárban levő
              összes olyan fájlt és alkönyvtárat,  amelyet  1991.  december  7-én  vagy
              később módosítottak utoljára.

       -T     Az  új  zip  file  ellenőrzése.  Ha  hibát  talál,  akkor a régi zip file
              változatlanul marad és (a  -m  kapcsolóval  együtt)  nem  töröl  egyetlen
              becsomagolt fájlt sem.

       -u     Csak  akkor cserél le (frissít) egy a zip archívumban már szereplő fájlt,
              ha később módosították, mint a zip archívumban levő változatát. Például:

                     zip -u cucc *

              Ez a parancs az aktuális könyvtárból hozzáad  az  archívumhoz  minden  új
              fájlt,   és   frissíti   azokat   a   fájlokat,   amelyeket   a  cucc.zip
              létrehozása/utolsó módosítása óta módosítottak. (A zip nem fogja önmagába
              becsomagolni a cucc.zip-et.)

              Megjegyzés:  a  -u  opció  argumentumok  nélkül  úgy  működik,  mint a -f
              (frissítés) opció.

       -v     Részletes kiírás mód vagy információk az aktuális verzióról.

              Ha rendes műveletekkel együtt használjuk, akkor tömörítés közben mutatja,
              hogy  éppen  hol  tart,  és  részletes  adatokat  szolgáltat  a  zip file
              szerkezetének érdekességeiről.

              Ha a -v az egyetlen argumentum, és a szabványos  kimenet  nincsen  fájlba
              irányítva,  akkor egy információs képernyőt kapunk. A copyright-jelzés, a
              program neve, verziószáma, a kiadás dátuma mellett megadja az Info-ZIP és
              a  terjesztő  helyek  címét is. Ezután következik néhány információ a zip
              program fordításáról (a használt fordító típusa és verziója, az operációs
              rendszer  verziója,  a  fordítás  időpontja,  és a program létrehozásakor
              bekapcsolt fordítási opciók).

       -V     VMS file attribútumok mentése. Ez az opció csak VMS alatt működik, a vele
              létrehozott   zip   file-ok   más   rendszereken  általában  nem  lesznek
              használhatók.

       -w     A verziószámok hozzácsatolása a fájlnevekhez, a fájlok több verzióját  is
              tárolja. (Csak VMS-ben; alapértelmezés: csak a fájlok legutóbbi verzióját
              használja.)

       -x fájlok
              Kihagyja a megadott fájlokat, például a

                     zip -r valami valami -x \*.o

              parancs a valami könyvtár tartalmát tárolja a valami.zip-ben,  de  kihagy
              minden .o-ra végződő nevű fájlt.  A "\" megakadályozza a parancsértelmező
              automatikus fájlnév  helyettesítését,  így  a  nevek  illesztését  minden
              alkönyvtár-szinten a zip fogja végezni.

       -X     Nem tárolja a speciális fájlattribútumokat (Kiterjesztett attribútumok az
              OS/2-nél, uid/gid és file módosítási idők a Unix-nál.)

       -y     A szimbolikus linkeket önmagukban tárolja a zip file-ban, ahelyett,  hogy
              a linkek által hivatkozott fájlokat tömörítené.  (Csak Unix-nál.)

       -z     Az   egész  zip  file-ra  vonatkozó  többsoros  megjegyzést  olvas  be  a
              terminálról.  A megjegyzés végét egy egyetlen pontot tartalmazó sor, vagy
              a  fájlvége jel jelzi (^D Unix-on, ^Z MSDOS-on, OS/2-n és VAX/VMS-en).  A
              megjegyzést fájlból is be lehet vinni:

                     zip -z valami < mejegyzes

       -#     A # számjegy megadásával szabályozza a tömörítés  sebességét:  -0:  nincs
              tömörítés (csak tárol minden fájlt), -1: a leggyorsabb tömörítési módszer
              (gyengébb tömörítés), és -9: a  leglassabb tömörítési módszer  (optimális
              tömörítés,   nem   veszi   figyelembe   a   fájlnevek   végződését).   Az
              alapértelmezett tömörítési szint a -6.

       -@     A tömörítendő fájlok listáját a szabványos bemenetről  veszi.  A  szóközt
              tartalmazó  fájlneveket  aposztrófok  között kell megadni, például: 'file
              név'.

       -$     Az első tömörítendő fájlt tartalmazó meghajtó kötetnevét is tárolja.   Ha
              csak  a  kötetnevet akarjuk tárolni, vagy meg akarunk határozni egy adott
              meghajtót, akkor első fájlként írjuk a meghajtó nevét, például:

                     zip -$ valami a: c:akarmi

              Ez az opció csak néhány rendszeren működik (MSDOS és OS/2), Unix-on nincs
              hatása.

PÉLDÁK
       A legegyszerűbb példa:

              zip cucc *

       Ez létrehozza a cucc.zip archívumot (feltéve, hogy korábban nem létezett), és az
       aktuális könyvtárban levő összes fájlt tárolja  benne  tömörített  formában.  (A
       .zip  végződés automatikusan hozzáíródik az archívum file nevéhez, kivéve, ha az
       már tartalmazott pontot. Így explicit módon megadható más végződés is.)

       A parancsértelmező fájlnév helyettesítési mechanizmusa miatt a  "."-tal  kezdődő
       fájlok nem kerülnek be az archívumba.  Ha ezeket is hozzá akarjuk venni:

              zip cucc .* *

       De ez sem tárolja az aktuális könyvtárból nyíló alkönyvtárakat.

       Ha egy teljes könyvtárat akarunk zip-pelni:

              zip -r valami valami

       Ez  a  parancs  létrehozza  a  valami.zip  archívumot,  amibe  bekerül  a valami
       alkönyvtárban levő összes file és alkönyvtár.

       Szükség lehet arra, hogy olyan zip archívumot hozzunk létre, amely tartalmazza a
       fájlokat  a  valami  könyvtárból,  de  a valami könyvtárnevet nem tárolja.  A -j
       opció segítségével levághatjuk az elérési utakat, például:

              zip -j valami valami/*

       Ha kevés a szabad lemezterület, akkor előfordulhat, hogy az eredeti könyvtár  és
       a  tömörített  változata  nem fér el együtt.  Ebben az esetben létrehozhatjuk az
       archívumot lépésekben is, a  -m  opció  használatával.   Ha  a  valami  könyvtár
       tartalmazza a pista, feri, és jancsi alkönyvtárakat, akkor megtehetjük ezt:

              zip -rm valami valami/pista
              zip -rm valami valami/feri
              zip -rm valami valami/jancsi

       Az  első parancs létrehozza a valami.zip-et, és a másik kettő bővíti.  Mindegyik
       zip parancs végrehajtása után az utoljára létrehozott  archívum  törlődik,  elég
       helyet hagyva a következő zip parancs működéséhez.

MINTAILLESZTÉS
       Ez a rész csak a UNIX-ra vonatkozik.

       A  UNIX  parancsértelmezői  (sh(1) és csh(1)) file-név helyettesítést végeznek a
       parancsok argumentumain.  A speciális karakterek:

       ?      egyetlen tetszőleges karaktert helyettesít

       *      tetszőleges számú karaktert helyettesít (beleértve a nullát is)

       []     a szögletes zárójelekben megadott tartományba tartozó egyetlen  karaktert
              helyettesít (például: [a-f], [0-9]).

       Amikor a parancsértelmező ezekkel a karakterekkel találkozik (ha nincsenek védve
       "\" karakterrel vagy  idézőjelekkel),  akkor  az  aktuális  elérési  úton  olyan
       fájlokat  fog keresni, amelyek neve illeszkedik a megadott mintára, és ezeknek a
       fájloknak a listájával helyettesíti az argumentumot.

       A zip program is képes elvégezni ugyanezt a  helyettesítést  a  módosítandó  zip
       archívumban  levő  fájlokra, illetve a -x (kizárás) vagy -i (beillesztés) opciók
       esetében a megadott fájllistán (ha "\" karaktert vagy  idézőjeleket  használunk,
       hogy    megakadályozzuk   a   parancsértelmező   automatikus   helyettesítését).
       Általánosan, amikor a zip a listában feldolgoz  egy  fájlnevet,  akkor  a  fájlt
       először  a  fájlrendszerben  keresi. Ha ott nem találja, akkor a módosítandó zip
       archívumban  (ha  van  ilyen)  keresi  a   fenti   mintaillesztő   karaktereknek
       megfelelően.  Minden  illeszkedő  file  nevet  felvesz  a  feldolgozandó  fájlok
       listájába, kivéve, ha az a -x opcióval megadott fájlok között  van,  illetve  ha
       nincs a -i opcióval megadott fájlok között.

       A  mintaillesztésbe az elérési út is beletartozik, tehát például a \*.o mintának
       megfelel minden ".o"-ra  végződő  file,  függetlenül  az  elérési  út  elejétől.
       Jegyezzük  meg, hogy minden speciális karakter (pl. ?*[]) elé "\" karaktert kell
       írni, vagy az egész argumentumot dupla idézőjelek ("") közé kell tenni.

       Általában  használjunk   "\"   karaktert,   hogy   a   zip-pel   végeztessük   a
       mintaillesztést  a  -f  (frissítés)  és  -d  (törlés)  opcióknál,  és  néha a -x
       (kizárás) opció után is, ha a megfelelő művelettel  használjuk  (hozzáadás,  -u,
       -f, vagy -d).

LÁSD MÉG
       compress(1), shar(1), tar(1), unzip(1), gzip(1)

HIBÁK
       A  zip 2.1 nem kompatíbilis a PKUNZIP 1.10-zel. A zip 1.1 használatával tudunk a
       PKUNZIP 1.10-zel kicsomagolható zip file-okat létrehozni.

       A zip 2.1-el létrehozott zip file-okat nem szabad módosítani a zip 1.1-el vagy a
       PKZIP  1.10-zel,  ha  titkosított  tagokat is tartalmaznak, illetve ha pipe-ról,
       vagy soros hozzáférésű eszközről hoztuk őket létre.  A zip  vagy  a  PKZIP  régi
       verziói  hibás  formátumú  archívumot  hoznának létre.  A régi verziók ki tudják
       listázni a zip file tartalmát,  de  nem  tudják  kicsomagolni  (az  új  tömörítő
       algoritmus  miatt).   Ha nem használunk titkosítást, és csak közönséges, lemezen
       levő fájlokat használunk, akkor nem kell törődnünk ezzel a problémával.

       VMS alatt a zip nem kezel megfelelően minden speciális file formátumot.  Csak  a
       "stream-LF" formátumú zip file-ok működnek a zip-pel.  Más fájlok konvertálhatók
       Rahul Dhesi BILF programjával.  A zip ezen  verziója  elvégzi  a  konverzió  egy
       részét.   Ha  Kermit-et használunk zip fájlok másolására Vax-tól MSDOS-ra, akkor
       írjuk be a Vax-on, hogy "set file type block".  Ha  MSDOS-ról  Vax-ra  másolunk,
       akkor írjuk be a Vax-on, hogy "set file type fixed". Mindkét esetben az MSDOS-on
       írjuk be azt, hogy "set file type binary".

       VMS alatt a zip elszáll, ha DECnet szintaxis  szerinti  fájlspecifikációt  adunk
       meg, például: valami::*.*.

       OS/2-n  a  zip  nem  tud  megtalálni  néhány file nevet, például azokat, amelyek
       felkiáltójelet vagy kettőskeresztet tartalmaznak. Ez a hiba az OS/2-ben  van:  a
       32  bites  DosFindFirst/Next  nem  találja meg az ilyen file neveket. A hiba más
       programokat is érint, például a GNU tar-t.

       OS/2 alatt (kompatibilitási okokból)  a  DIR  annyi  kiterjesztett  attribútumot
       mutat,  amennyit  a  DosQueryPathInfo()  16  bites  verziója visszaad. Ellenkező
       esetben az 1.3-as és a 2.0-ás OS/2-n a DIR különböző értékeket  mutatna.   A  32
       bites  DosQueryPathInfo() által visszaadott adatszerkezet egy kicsit különbözik,
       extra byte-okat tartalmaz a 4 byte-os határra igazítás miatt  (hogy  megfeleljen
       az  OS/2  későbbi  RISC verzióinak), valamint pointereket (valójában egy láncolt
       lista). Ezért a zip által mutatott érték (mivel a zip a  32  bites  mód  méretét
       használja) különbözik attól, amit a DIR mutat. A zip hordozhatósági okokból a 32
       bites formátumot tárolja, még az OS/2 1.3-on futó 16 bites  MS  C-vel  fordított
       változat is, tehát ez is a 32 bites mód méretét mutatja.

       Az Amigán a -A opció egyelőre nem működik.

SZERZŐK
       Copyright (C) 1990-1996 Mark Adler, Richard B. Wales, Jean-loup Gailly, Onno van
       der Linden, Kai Uwe Rommel, Igor Mandrichenko, John Bush and Paul Kienitz.   Ezt
       a  programot  bármely  személy  vagy  intézmény  használhatja,  másolhatja, vagy
       terjesztheti mindaddig, amíg az összes eredeti fájlt együtt tartja.   A  program
       eladásából  nem  szerezhet jövedelmet, és ezt a copyright szöveget változatlanul
       kell hagynia.

       UGYANÚGY,  MINT  MÁS  INGYENES  DOLGOKNÁL,  A  ZIP-HEZ  ÉS   A   HOZZÁ   TARTOZÓ
       SEGÉDPROGRAMOKHOZ  NEM  JÁR  SEMMILYEN  GARANCIA.  A SZERZŐI JOGOK TULAJDONOSAIT
       SEMMILYEN ESETBEN SEM TERHELI FELELŐSSÉG A PROGRAM HASZNÁLATÁBÓL ADÓDÓ BÁRMILYEN
       KÁROKÉRT.

       Az eredeti szöveg:

       Permission  is  granted  to  any  individual  or  institution  to  use, copy, or
       redistribute this software so long as all of the original  files  are  included,
       that it is not sold for profit, and that this copyright notice is retained.

       LIKE ANYTHING ELSE THAT'S FREE, ZIP AND ITS ASSOCIATED UTILITIES ARE PROVIDED AS
       IS AND COME WITH NO WARRANTY OF ANY KIND, EITHER EXPRESSED  OR  IMPLIED.  IN  NO
       EVENT  WILL  THE  COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES RESULTING FROM THE
       USE OF THIS SOFTWARE.

       A hibájelentéseket és a megjegyzéseket küldd a zip-bugs@wkuvx1.wku.edu címre.  A
       hibajelentésekhez  csatold  a  zip  verziószámát  (lásd  zip -h ), a fordításnál
       használt make opciókat (lásd zip -v ), a  gép  típusát,  az  operációs  rendszer
       nevét és verzióját, valamint minél több kiegészítő információt!

KÖSZÖNETNYILVÁNÍTÁS
       Szeretnénk  köszönetet  mondani R. P. Byrne-nek a Shrink.Pas programjáért, amely
       ezt a projektet ihlette, és amiből a "shrink" algoritmust loptuk; Phil Katz-nak,
       amiért  a  zip  file-formátumot,  tömörítési  formátumot és a .ZIP kiterjesztést
       public domain-be tette, és amiért elfogadott néhány kisebb  módosítást  a  file-
       formátumon;   Steve   Burg-nek  a  "deflate"  formátum  tisztázásáért;  Haruhiko
       Okumurának és Leonid  Broukhis-nek  a  tömörítési  algoritmushoz  adott  hasznos
       ötleteikért;  Keith  Petersen-nek,  Rich  Wales-nek,  Hunter Goatley-nak és Mark
       Adler-nek, amiért fenntartják az INFO-ZIP csoport  levelezési  listáját  és  ftp
       szerverét;  és legfőképpen az INFO-ZIP csoport tagjainak (a lista az infozip.who
       file-ban van), akiknek a fáradhatatlan tesztelési és hibajavítási munkája nélkül
       egy  hordozható  zip  létrehozása  nem  lett volna lehetséges.  Végül szeretnénk
       megköszönni  (szemrehányást  tenni)  az  első   INFO-ZIP   moderátornak,   David
       Kirschbaum-nak,  amiért  egyáltalán  belevitt  minket  ebbe  az  egészbe.  Ezt a
       dokumentációt R. P. C. Rodgers írta át UNIX-ra.

MAGYAR FORDÍTÁS
       Dénes Pál <denespal@valerie.inf.elte.hu>

                                      1996 Apr 13                                ZIP(1)

Copyright (c) 1990-2008 Info-ZIP - Type 'zip "-L"' for software license.
Zip 3.0 (July 5th 2008). Usage:
zip [-options] [-b path] [-t mmddyyyy] [-n suffixes] [zipfile list] [-xi list]
  The default action is to add or replace zipfile entries from list, which
  can include the special name - to compress standard input.
  If zipfile and list are omitted, zip compresses stdin to stdout.
  -f   freshen: only changed files  -u   update: only changed or new files
  -d   delete entries in zipfile    -m   move into zipfile (delete OS files)
  -r   recurse into directories     -j   junk (don't record) directory names
  -0   store only                   -l   convert LF to CR LF (-ll CR LF to LF)
  -1   compress faster              -9   compress better
  -q   quiet operation              -v   verbose operation/print version info
  -c   add one-line comments        -z   add zipfile comment
  -@   read names from stdin        -o   make zipfile as old as latest entry
  -x   exclude the following names  -i   include only the following names
  -F   fix zipfile (-FF try harder) -D   do not add directory entries
  -A   adjust self-extracting exe   -J   junk zipfile prefix (unzipsfx)
  -T   test zipfile integrity       -X   eXclude eXtra file attributes
  -y   store symbolic links as the link instead of the referenced file
  -e   encrypt                      -n   don't compress these suffixes
  -h2  show more help

---------


Extended Help for Zip

See the Zip Manual for more detailed help


Zip stores files in zip archives.  The default action is to add or replace
zipfile entries.

Basic command line:
  zip options archive_name file file ...

Some examples:
  Add file.txt to z.zip (create z if needed):      zip z file.txt
  Zip all files in current dir:                    zip z *
  Zip files in current dir and subdirs also:       zip -r z .

Basic modes:
 External modes (selects files from file system):
        add      - add new files/update existing files in archive (default)
  -u    update   - add new files/update existing files only if later date
  -f    freshen  - update existing files only (no files added)
  -FS   filesync - update if date or size changed, delete if no OS match
 Internal modes (selects entries in archive):
  -d    delete   - delete files from archive (see below)
  -U    copy     - select files in archive to copy (use with --out)

Basic options:
  -r        recurse into directories (see Recursion below)
  -m        after archive created, delete original files (move into archive)
  -j        junk directory names (store just file names)
  -q        quiet operation
  -v        verbose operation (just "zip -v" shows version information)
  -c        prompt for one-line comment for each entry
  -z        prompt for comment for archive (end with just "." line or EOF)
  -@        read names to zip from stdin (one path per line)
  -o        make zipfile as old as latest entry


Syntax:
  The full command line syntax is:

    zip [-shortopts ...] [--longopt ...] [zipfile [path path ...]] [-xi list]

  Any number of short option and long option arguments are allowed
  (within limits) as well as any number of path arguments for files
  to zip up.  If zipfile exists, the archive is read in.  If zipfile
  is "-", stream to stdout.  If any path is "-", zip stdin.

Options and Values:
  For short options that take values, use -ovalue or -o value or -o=value
  For long option values, use either --longoption=value or --longoption value
  For example:
    zip -ds 10 --temp-dir=path zipfile path1 path2 --exclude pattern pattern
  Avoid -ovalue (no space between) to avoid confusion
  In particular, be aware of 2-character options.  For example:
    -d -s is (delete, split size) while -ds is (dot size)
  Usually better to break short options across multiple arguments by function
    zip -r -dbdcds 10m -lilalf logfile archive input_directory -ll

  All args after just "--" arg are read verbatim as paths and not options.
    zip zipfile path path ... -- verbatimpath verbatimpath ...
  Use -nw to also disable wildcards, so paths are read literally:
    zip zipfile -nw -- "-leadingdashpath" "a[path].c" "path*withwildcard"
  You may still have to escape or quote arguments to avoid shell expansion

Wildcards:
  Internally zip supports the following wildcards:
    ?       (or %% or #, depending on OS) matches any single character
    *       matches any number of characters, including zero
    [list]  matches char in list (regex), can do range [ac-f], all but [!bf]
  If port supports [], must escape [ as [[] or use -nw to turn off wildcards
  For shells that expand wildcards, escape (\* or "*") so zip can recurse
    zip zipfile -r . -i "*.h"

  Normally * crosses dir bounds in path, e.g. 'a*b' can match 'ac/db'.  If
   -ws option used, * does not cross dir bounds but ** does

  For DOS and Windows, [list] is now disabled unless the new option
  -RE       enable [list] (regular expression) matching
  is used to avoid problems with file paths containing "[" and "]":
    zip files_ending_with_number -RE foo[0-9].c

Include and Exclude:
  -i pattern pattern ...   include files that match a pattern
  -x pattern pattern ...   exclude files that match a pattern
  Patterns are paths with optional wildcards and match paths as stored in
  archive.  Exclude and include lists end at next option, @, or end of line.
    zip -x pattern pattern @ zipfile path path ...

Case matching:
  On most OS the case of patterns must match the case in the archive, unless
  the -ic option is used.
  -ic       ignore case of archive entries
  This option not available on case-sensitive file systems.  On others, case
  ignored when matching files on file system but matching against archive
  entries remains case sensitive for modes -f (freshen), -U (archive copy),
  and -d (delete) because archive paths are always case sensitive.  With
  -ic, all matching ignores case, but it's then possible multiple archive
  entries that differ only in case will match.

End Of Line Translation (text files only):
  -l        change CR or LF (depending on OS) line end to CR LF (Unix->Win)
  -ll       change CR LF to CR or LF (depending on OS) line end (Win->Unix)
  If first buffer read from file contains binary the translation is skipped

Recursion:
  -r        recurse paths, include files in subdirs:  zip -r a path path ...
  -R        recurse current dir and match patterns:   zip -R a ptn ptn ...
  Use -i and -x with either to include or exclude paths
  Path root in archive starts at current dir, so if /a/b/c/file and
   current dir is /a/b, 'zip -r archive .' puts c/file in archive

Date filtering:
  -t date   exclude before (include files modified on this date and later)
  -tt date  include before (include files modified before date)
  Can use both at same time to set a date range
  Dates are mmddyyyy or yyyy-mm-dd

Deletion, File Sync:
  -d        delete files
  Delete archive entries matching internal archive paths in list
    zip archive -d pattern pattern ...
  Can use -t and -tt to select files in archive, but NOT -x or -i, so
    zip archive -d "*" -t 2005-12-27
  deletes all files from archive.zip with date of 27 Dec 2005 and later
  Note the * (escape as "*" on Unix) to select all files in archive

  -FS       file sync
  Similar to update, but files updated if date or size of entry does not
  match file on OS.  Also deletes entry from archive if no matching file
  on OS.
    zip archive_to_update -FS -r dir_used_before
  Result generally same as creating new archive, but unchanged entries
  are copied instead of being read and compressed so can be faster.
      WARNING:  -FS deletes entries so make backup copy of archive first

Compression:
  -0        store files (no compression)
  -1 to -9  compress fastest to compress best (default is 6)
  -Z cm     set compression method to cm:
              store   - store without compression, same as option -0
              deflate - original zip deflate, same as -1 to -9 (default)
            if bzip2 is enabled:
              bzip2 - use bzip2 compression (need modern unzip)

Encryption:
  -e        use standard (weak) PKZip 2.0 encryption, prompt for password
  -P pswd   use standard encryption, password is pswd

Splits (archives created as a set of split files):
  -s ssize  create split archive with splits of size ssize, where ssize nm
              n number and m multiplier (kmgt, default m), 100k -> 100 kB
  -sp       pause after each split closed to allow changing disks
      WARNING:  Archives created with -sp use data descriptors and should
                work with most unzips but may not work with some
  -sb       ring bell when pause
  -sv       be verbose about creating splits
      Split archives CANNOT be updated, but see --out and Copy Mode below

Using --out (output to new archive):
  --out oa  output to new archive oa
  Instead of updating input archive, create new output archive oa.
  Result is same as without --out but in new archive.  Input archive
  unchanged.
      WARNING:  --out ALWAYS overwrites any existing output file
  For example, to create new_archive like old_archive but add newfile1
  and newfile2:
    zip old_archive newfile1 newfile2 --out new_archive
  Cannot update split archive, so use --out to out new archive:
    zip in_split_archive newfile1 newfile2 --out out_split_archive
  If input is split, output will default to same split size
  Use -s=0 or -s- to turn off splitting to convert split to single file:
    zip in_split_archive -s 0 --out out_single_file_archive
      WARNING:  If overwriting old split archive but need less splits,
                old splits not overwritten are not needed but remain

Copy Mode (copying from archive to archive):
  -U        (also --copy) select entries in archive to copy (reverse delete)
  Copy Mode copies entries from old to new archive with --out and is used by
  zip when either no input files on command line or -U (--copy) used.
    zip inarchive --copy pattern pattern ... --out outarchive
  To copy only files matching *.c into new archive, excluding foo.c:
    zip old_archive --copy "*.c" --out new_archive -x foo.c
  If no input files and --out, copy all entries in old archive:
    zip old_archive --out new_archive

Streaming and FIFOs:
  prog1 | zip -ll z -      zip output of prog1 to zipfile z, converting CR LF
  zip - -R "*.c" | prog2   zip *.c files in current dir and stream to prog2 
  prog1 | zip | prog2      zip in pipe with no in or out acts like zip - -
  If Zip is Zip64 enabled, streaming stdin creates Zip64 archives by default
   that need PKZip 4.5 unzipper like UnZip 6.0
  WARNING:  Some archives created with streaming use data descriptors and
            should work with most unzips but may not work with some
  Can use -fz- to turn off Zip64 if input not large (< 4 GB):
    prog_with_small_output | zip archive -fz-

  Zip now can read Unix FIFO (named pipes).  Off by default to prevent zip
  from stopping unexpectedly on unfed pipe, use -FI to enable:
    zip -FI archive fifo

Dots, counts:
  -db       display running count of bytes processed and bytes to go
              (uncompressed size, except delete and copy show stored size)
  -dc       display running count of entries done and entries to go
  -dd       display dots every 10 MB (or dot size) while processing files
  -dg       display dots globally for archive instead of for each file
    zip -qdgds 10m   will turn off most output except dots every 10 MB
  -ds siz   each dot is siz processed where siz is nm as splits (0 no dots)
  -du       display original uncompressed size for each entry as added
  -dv       display volume (disk) number in format in_disk>out_disk
  Dot size is approximate, especially for dot sizes less than 1 MB
  Dot options don't apply to Scanning files dots (dot/2sec) (-q turns off)

Logging:
  -lf path  open file at path as logfile (overwrite existing file)
  -la       append to existing logfile
  -li       include info messages (default just warnings and errors)

Testing archives:
  -T        test completed temp archive with unzip before updating archive
  -TT cmd   use command cmd instead of 'unzip -tqq' to test archive
             On Unix, to use unzip in current directory, could use:
               zip archive file1 file2 -T -TT "./unzip -tqq"
             In cmd, {} replaced by temp archive path, else temp appended.
             The return code is checked for success (0 on Unix)

Fixing archives:
  -F        attempt to fix a mostly intact archive (try this first)
  -FF       try to salvage what can (may get more but less reliable)
  Fix options copy entries from potentially bad archive to new archive.
  -F tries to read archive normally and copy only intact entries, while
  -FF tries to salvage what can and may result in incomplete entries.
  Must use --out option to specify output archive:
    zip -F bad.zip --out fixed.zip
  Use -v (verbose) with -FF to see details:
    zip reallybad.zip -FF -v --out fixed.zip
  Currently neither option fixes bad entries, as from text mode ftp get.

Difference mode:
  -DF       (also --dif) only include files that have changed or are
             new as compared to the input archive
  Difference mode can be used to create incremental backups.  For example:
    zip --dif full_backup.zip -r somedir --out diff.zip
  will store all new files, as well as any files in full_backup.zip where
  either file time or size have changed from that in full_backup.zip,
  in new diff.zip.  Output archive not excluded automatically if exists,
  so either use -x to exclude it or put outside what is being zipped.

DOS Archive bit (Windows only):
  -AS       include only files with the DOS Archive bit set
  -AC       after archive created, clear archive bit of included files
      WARNING: Once the archive bits are cleared they are cleared
               Use -T to test the archive before the bits are cleared
               Can also use -sf to save file list before zipping files

Show files:
  -sf       show files to operate on and exit (-sf- logfile only)
  -su       as -sf but show escaped UTF-8 Unicode names also if exist
  -sU       as -sf but show escaped UTF-8 Unicode names instead
  Any character not in the current locale is escaped as #Uxxxx, where x
  is hex digit, if 16-bit code is sufficient, or #Lxxxxxx if 24-bits
  are needed.  If add -UN=e, Zip escapes all non-ASCII characters.

Unicode:
  If compiled with Unicode support, Zip stores UTF-8 path of entries.
  This is backward compatible.  Unicode paths allow better conversion
  of entry names between different character sets.

  New Unicode extra field includes checksum to verify Unicode path
  goes with standard path for that entry (as utilities like ZipNote
  can rename entries).  If these do not match, use below options to
  set what Zip does:
      -UN=Quit     - if mismatch, exit with error
      -UN=Warn     - if mismatch, warn, ignore UTF-8 (default)
      -UN=Ignore   - if mismatch, quietly ignore UTF-8
      -UN=No       - ignore any UTF-8 paths, use standard paths for all
  An exception to -UN=N are entries with new UTF-8 bit set (instead
  of using extra fields).  These are always handled as Unicode.

  Normally Zip escapes all chars outside current char set, but leaves
  as is supported chars, which may not be OK in path names.  -UN=Escape
  escapes any character not ASCII:
    zip -sU -UN=e archive
  Can use either normal path or escaped Unicode path on command line
  to match files in archive.

  Zip now stores UTF-8 in entry path and comment fields on systems
  where UTF-8 char set is default, such as most modern Unix, and
  and on other systems in new extra fields with escaped versions in
  entry path and comment fields for backward compatibility.
  Option -UN=UTF8 will force storing UTF-8 in entry path and comment
  fields:
      -UN=UTF8     - store UTF-8 in entry path and comment fields
  This option can be useful for multi-byte char sets on Windows where
  escaped paths and comments can be too long to be valid as the UTF-8
  versions tend to be shorter.

  Only UTF-8 comments on UTF-8 native systems supported.  UTF-8 comments
  for other systems planned in next release.

Self extractor:
  -A        Adjust offsets - a self extractor is created by prepending
             the extractor executable to archive, but internal offsets
             are then off.  Use -A to fix offsets.
  -J        Junk sfx - removes prepended extractor executable from
             self extractor, leaving a plain zip archive.

More option highlights (see manual for additional options and details):
  -b dir    when creating or updating archive, create the temp archive in
             dir, which allows using seekable temp file when writing to a
             write once CD, such archives compatible with more unzips
             (could require additional file copy if on another device)
  -MM       input patterns must match at least one file and matched files
             must be readable or exit with OPEN error and abort archive
             (without -MM, both are warnings only, and if unreadable files
             are skipped OPEN error (18) returned after archive created)
  -nw       no wildcards (wildcards are like any other character)
  -sc       show command line arguments as processed and exit
  -sd       show debugging as Zip does each step
  -so       show all available options on this system
  -X        default=strip old extra fields, -X- keep old, -X strip most
  -ws       wildcards don't span directory boundaries in paths