Halaman ini berisi artikel tentang pemetaan data. Untuk perangkat lunak komputer, lihat kompresi data.
Dalam ilmu komputer, **zip** adalah fungsi yang memetakan rangkap dari barisan menjadi barisan dari rangkap. Nama *zip* berasal dari bahasa Inggris *zipping* atau *zipper* (ritsleting) yang secara selang-seling menggabungkan dua barisan yang terpisah. Inversi fungsi ini disebut *unzip*.

Contoh
------

Misalkan ada tiga kata *ia*, *tuk*, dan *palu* (2, 3, dan 4 karakter). Misalkan pula {\displaystyle \ell } menandakan jumlah karakter terbanyak dari ketiganya, yaitu {\displaystyle \ell =4} (kata *palu*). Hasil operasi zip terhadap *ia*, *tuk*, dan *palu* adalah barisan berisi 4 rangkap berikut:

{\displaystyle (i,t,p),(a,u,a),(\#,k,l),(\#,\#,u)}
dengan *#* adalah simbol di luar alfabet yang awalnya dipakai.

Pada bahasa pemrograman tertentu seperti Haskell, fungsi ini hanya mengembalikan sebanyak jumlah karakter terpendek, yaitu {\displaystyle \ell =2} (kata *ia*):

```
zip3 "ia" "tuk" "palu"
-- [('i','t','p'),('a','u','a')]

```

Definisi
--------

Misalkan Σ adalah alfabet dan *#* adalah simbol di luar Σ.

Misalkan *x*1*x*2...*x*|*x*|, *y*1*y*2...*y*|*y*|, *z*1*z*2...*z*|*z*|, ... adalah *n* kata (barisan berhingga) yang tersusun dari anggota Σ. Misalkan pula {\displaystyle \ell } adalah panjang maksimum kata, yaitu maksimum dari |*x*|, |*y*|, |*z*|, ....

Hasil operasi zip dari kata-kata tersebut adalah barisan berhingga dari rangkap-*n* yang disusun dari anggota (Σ ∪ {*#*}), dengan kata lain anggota dari ((Σ ∪ {*#*})*n*)\*:

{\displaystyle (x\_{1},y\_{1},z\_{1},\ldots ,(x\_{2},y\_{2},z\_{2},\ldots ),\ldots ,(x\_{\ell },y\_{\ell },z\_{\ell },\ldots ),\ldots }
dengan *wi* adalah *#* untuk *i* > |*w*| dan *w* adalah tiap kata.

Operasi zip terhadap *x*, *y*, *z*, ... disimbolkan sebagai zip(*x*, *y*, *z*, ...) atau *x* ⋆ *y* ⋆ *z* ⋆ .... Inversi operasi zip disimbolkan sebagai unzip(...).

Variasi operasi zip yang hanya mengembalikan dengan panjang minimum kata bisa didefinisikan sebagai berikut:

{\displaystyle (x\_{1},y\_{1},z\_{1},\ldots ,(x\_{2},y\_{2},z\_{2},\ldots ),\ldots ,(x\_{\underline {\ell }},y\_{\underline {\ell }},z\_{\underline {\ell }},\ldots )}
dengan {\displaystyle {\underline {\ell }}} adalah panjang *minimum* dari kata-kata yang diberikan. Variasi ini menghindari anggota tambahan *#*, tetapi menghapus informasi tentang barisan masukan setelah ke-{\displaystyle {\underline {\ell }}}.

Dalam bahasa pemrograman
------------------------

Fungsi zip tersedia dalam beberapa bahasa pemrograman dan biasa disebut `zip`. Dalam dialek Lisp, operasi zip bisa dilakukan dengan fungsi `map` yang diterapkan terhadap daftar yang diinginkan. Fungsi `map` dalam Lisp bersifat  variadik sehingga bisa menerima banyak argumen. Berikut contoh dalam bahasa Clojure:

```
;; `bilangan` berisi daftar bilangan sampai tak hingga (0 1 2 3 ...)
(def bilangan (range))
(def puluhan [10 20 30])
(def namadepan "Milea")

;; Untuk zip (0 1 2 3 ...) dan [10 20 30] ke dalam vector, panggil `map vector` terhadapnya; begitu pula untuk list
(map vector bilangan puluhan) ; ⇒ ([0 10] [1 20] [2 30])
(map list bilangan puluhan) ; ⇒ ((0 10) (1 20) (2 30))
(map str bilangan puluhan) ; ⇒ ("010" "120" "230")

;; `map` memotong sampai barisan terpendek; perhatikan "e" dan "a" dari "Milea"
(map vector bilangan puluhan namadepan) ; ⇒ ([0 10 "M"] [1 20 "i"] [2 30 "l"])
(map str bilangan puluhan namadepan) ; ⇒ ("010M" "120i" "230l")

;; Untuk unzip, terapkan `map vector` atau `map list`
(apply map list (map vector bilangan puluhan namadepan))
;; ⇒ ((0 1 2) (10 20 30) ("M" "i" "l"))

```

Bahasa-bahasa seperti Python memberikan fungsi `zip()`. Python versi lawas (2.x) membolehkan pemetaan dengan `None` untuk menghasilkan efek yang sama. Fungsi `zip()` dengan `*` melakukan operasi unzip.

Contoh berikut berlaku untuk Python 2.x. Terdapat perbedaan antara versi 2 dan 3 terhadap hasil dari fungsi `zip()`, yaitu sebagai daftar (versi 2) dan objek malas (versi 3).

```
>>> bilangan = [1, 2, 3]
>>> puluhan = [10, 20, 30]
>>> namadepan = 'Milea'

>>> zipped = zip(bilangan, puluhan)
>>> zipped
[(1, 10), (2, 20), (3, 30)]

>>> zip(\*zipped) # unzip
[(1, 2, 3), (10, 20, 30)]

>>> zipped2 = zip(bilangan, puluhan, list(namadepan))
>>> zipped2 # zip, memangkas sampai yang paling pendek
[(1, 10, 'M'), (2, 20, 'i'), (3, 30, 'l')]
>>> zip(\*zipped2) # unzip
[(1, 2, 3), (10, 20, 30), ('M', 'i', 'l')]

>>> # pemetaan dengan `None` tidak memangkasnya; dianggap usang dalam Python 3.
>>> map(None, bilangan, puluhan, list(namadepan))
[(1, 10, 'M'), (2, 20, 'i'), (3, 30, 'l'), (None, None, 'e'), (None, None, 'a')]

```

Haskell memiliki metode untuk operasi zip, tetapi wajib menggunakan fungsi khusus untuk tiap ariti (misal `zip` untuk dua daftar, `zip3` untuk tiga daftar, dst.); selain itu, fungsi `unzip` dan `unzip3` juga tersedia untuk operasi unzip.

```
-- nums berisi daftar bilangan sampai tak hingga [1, 2, 3, ...]
bilangan = [1..]
puluhan = [10, 20, 30]
namadepan = "Milea"

zip bilangan puluhan
-- ⇒ [(1,10), (2,20), (3,30)] — zip, memangkas daftar tak hingga
unzip $ zip bilangan puluhan
-- ⇒ ([1,2,3], [10,20,30]) — unzip

zip3 bilangan puluhan namadepan
-- ⇒ [(1,10,'M'), (2,20,'i'), (3,30,'l')] — zip, memangkas
unzip3 $ zip3 bilangan puluhan namadepan
-- ⇒ ([1,2,3], [10,20,30], "Mil") — unzip

```

Perbandingan bahasa
-------------------

Berikut daftar bahasa yang mendukung operasi zip:

Zip dalam beragam bahasa| Bahasa | Zip | Zip 3 daftar | Zip *n* daftar | Catatan |
| --- | --- | --- | --- | --- |
| Chapel | `zip (iter1 iter2)` | `zip (iter1 iter2 iter3)` | `zip (iter1 ... itern)` | Ukuran tiap iterator wajib sama persis. |
| Clojure | `(map list daftar1 daftar2)``(map vector daftar1 daftar2)` | `(map list daftar1 daftar2 list3)``(map vector daftar1 daftar2 daftar3)` | `(map list daftar1 … daftarn)``(map vector daftar1 … daftarn)` | Berhenti setelah mencapai panjang daftar terpendek. |
| Common Lisp | `(mapcar #'list daftar1 daftar2)` | `(mapcar #'list daftar1 daftar2 daftar3)` | `(mapcar #'list daftar1 ... daftarn)` | Berhenti setelah mencapai panjang daftar terpendek. |
| D | `zip(rentang1, rentang2)``rentang1.zip(rentang2)` | `zip(rentang1, rentang2,range3)``rentang1.zip(rentang2, rentang3)` | `zip(rentang1, …, rentangN)``rentang1.zip(…, rentangN)` | Kebijakan berhenti bawaannya adalah yang terpendek, tetapi bisa disetel menjadi terpendek, terpanjang, atau wajib sama ukurannya. Bentuk kedua adalah contoh dari UFCS. |
| F# | `List.zip daftar1 daftar2``Seq.zip sumber1 sumber2``Array.zip larik1 larik2` | `List.zip3 daftar1 daftar2 daftar3``Seq.zip3 sumber1 sumber2 sumber3``Array.zip3 larik1 larik2 larik3` |  |  |
| Haskell | `zip daftar1 daftar2` | `zip3 daftar1 daftar2 daftar3` | `zipn daftar1 … daftarn` | `zipn` untuk *n* > 3 tersedia dalam modul `Data.List`. Berhenti setelah mencapai panjang daftar terpendek. |
| Python | `zip(daftar1, daftar2)` | `zip(daftar1, daftar2, daftar3)` | `zip(daftar1, …, daftarn)` | `zip()` dan `map()` (3.x) berhenti setelah mencapai panjang daftar terpendek, sedangkan `map()` (2.x) dan `itertools.zip\_longest()` (3.x) memanjangkan daftar yang lebih pendek dengan isian `None`. |
| Ruby | `daftar1.zip(daftar2)` | `daftar1.zip(daftar2, daftar3)` | `daftar1.zip(daftar1, .. daftarn)` | Hasilnya sepanjang `daftar1` (yang dikenai fungsi zip). Nilai `nil` akan dipakai untuk mengisi nilai yang kosong. |
| Scala | `daftar1.zip(daftar2)` |  |  | Berhenti setelah mencapai panjang daftar terpendek. |

Unzip dalam beragam bahasa| Bahasa | Unzip | Unzip 3 rangkap | Unzip *n* rangkap | Catatan |
| --- | --- | --- | --- | --- |
| Clojure | `(apply map vector hasilzip)` | `(apply map vector hasilzip)` | `(apply map vector hasilzip)` |  |
| Common Lisp | `(apply #'mapcar #'list hasilzip)` | `(apply #'mapcar #'list hasilzip)` | `(apply #'mapcar #'list hasilzip)` |  |
| F# | `List.unzip daftar1 daftar2``Seq.unzip sumber1 sumber2``Array.unzip larik1 larik2` | `List.unzip3 daftar1 daftar2 daftar3``Seq.unzip3 sumber1 sumber2 sumber3``Array.unzip3 larik1 larik2 larik3` |  |  |
| Haskell | `unzip hasilzip` | `unzip3 hasilzip` | `unzipn hasilzip` | `unzipn` untuk *n* > 3 tersedia dalam modul `Data.List`. |
| Python | `zip(\*hasilzip)` | `zip(\*hasilzip)` | `zip(\*hasilzip)` |  |

Lihat pula
----------

* Map (fungsi tingkat tinggi)

Referensi
---------

1. ↑  "map". *ClojureDocs* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
2. ↑  "2. Built-in Functions". *Python 2.7.18 documentation* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
3. ↑  "Built-in Functions". *Python 3.11.3 documentation* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
4. ↑  "Prelude | zip :: [a] -> [b] -> [(a, b)]". *Haskell Hackage* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
5. ↑  "Zippered Iteration | Statements". *Chapel Documentation 1.30* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
6. ↑  "std.range". *D Programming Language* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
7. ↑  "Class: Array (Ruby 3.1.0)" (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.
8. ↑  "scala.collection.IterableOps". *Scala Standard Library 2.13.10* (dalam bahasa Inggris). Diakses tanggal 17 Mei 2023.