What happens if the two lists have different lengths?

Zipping stops at the shorter list, exactly like Python's zip() built-in, so any extra tail items in the longer list are simply dropped from the output. There's no padding or error for mismatched lengths, it's the standard zip behavior.

What's the inverse of this tool?

List Unzipper, which takes a list of paired items (like the output of this tool) and splits each one back into two separate lists using the same glue string.

Can I change the glue string from the default ":"?

Yes, the pair-glue string is fully configurable; set it to anything, like " -> " or "|", and it's used to join each pair.

List Zipper - Interleave Two Lists Into Pairs

Overview

Introduction

Pairing up two related lists, like a list of keys and a list of values, into combined key:value entries is a common task when preparing data for another tool or format.

List Zipper does exactly this, interleaving two lists into pairs the same way Python's built-in zip() function does.

What Is List Zipper?

A list-pairing tool: it walks both lists in lockstep, joining the item at each matching position from List A and List B using a configurable glue string.

The output is one paired line per position, formatted as "itemA<glue>itemB", e.g. "a:1" with the default glue of ":".

How List Zipper Works

Both inputs are split into items using the shared selected separator, then paired up index by index: List A's first item with List B's first item, and so on.

Zipping stops as soon as the shorter of the two lists runs out, and each resulting pair is joined with the configurable glue string before being rejoined into the output list.

When To Use List Zipper

Use it to combine a list of keys with a list of values into ready-to-use "key:value" pairs.

It's handy for preparing paired data, like coordinates or labeled measurements, from two separately maintained lists.

Often used alongside List Unzipper, List Comparer and Common List Item Finder.

Features

Advantages

Matches the well-known, predictable semantics of Python's zip(), including its shorter-list-wins truncation behavior.
The glue string is fully configurable, not locked to a single fixed separator.

Limitations

Truncates to the shorter list's length; it never pads the shorter list to match the longer one.
If either list's items themselves contain the glue string, the pairing is still readable but List Unzipper will only split on the first occurrence when reversing it.

Examples

Zipping two equal-length lists

Input

List A: a, b, c
List B: 1, 2, 3

Output

a:1
b:2
c:3

Each item from List A is paired with the item at the same position in List B, using the default ":" glue.

Lists of different lengths

Input

List A: a, b, c
List B: 1, 2

Output

a:1
b:2

List B has only two items, so zipping stops after the second pair; List A's third item, "c", is dropped, matching Python's zip() truncation behavior.

Best Practices & Notes

Best Practices

Make sure both lists are the same length if you need every item represented; otherwise the extra tail of the longer list is silently dropped.
Pick a glue string that won't appear inside your items, to keep List Unzipper's reverse operation unambiguous.

Developer Notes

Zips by iterating `for (let i = 0; i < Math.min(itemsA.length, itemsB.length); i++)`, building each pair as a template-literal string `${itemsA[i]}${glue}${itemsB[i]}`, directly mirroring Python's zip() truncate-to-shortest semantics.

List Zipper Use Cases

Combining a list of keys with a list of values into paired "key:value" entries
Pairing coordinates, like separate X and Y value lists, into combined points
Preparing labeled data for import into another tool that expects paired entries

Common Mistakes

Expecting the longer list's extra items to be kept or padded; they're always dropped, matching zip()'s standard truncation behavior.
Choosing a glue string that also appears inside the list items, making the pairing ambiguous to reverse later.

Tips

If your lists differ in length and you need every item preserved, pad the shorter list with placeholder values first.
Use List Unzipper afterward with the same glue string to split the pairs back into two separate lists.

List Zipper