如何在JavaScript中无索引遍历数组多元素？对标Python zip用法

Great question! Let's break down how to replicate that overlapping triplet traversal from Python in JavaScript, covering both index-free approaches and the idiomatic JS practices.

First, a quick recap: your Python code uses zip() with sliced versions of the list to create overlapping triplets, then iterates over those groups. Let's look at how to do this in JS.

Option 1: No explicit index handling in your main code #

If you want to avoid dealing with index variables like i directly in your core logic, you can encapsulate the sliding window work in a reusable function or use array utilities to hide the index math.

Using a Generator Function #

Generators let you tuck away the index-based logic, so your main code only interacts with the triplet values:

function* slidingWindow(arr, windowSize) {
  // The generator handles the index calculations internally
  for (let i = 0; i <= arr.length - windowSize; i++) {
    yield arr.slice(i, i + windowSize);
  }
}

// Usage
const foo = ["some", "random", "list", "foo"];
for (const [a, b, c] of slidingWindow(foo, 3)) {
  console.log(`${a} ${b} ${c}`);
}
// Output:
// some random list
// random list foo

Using Array.from to Precompute Triplets #

You can also generate all triplets upfront without manually writing an index loop in your main code:

const foo = ["some", "random", "list", "foo"];
// Array.from handles the index logic in its callback
const triplets = Array.from(
  { length: foo.length - 2 },
  (_, index) => [foo[index], foo[index+1], foo[index+2]]
);

// Traverse the precomputed triplets
triplets.forEach(([a, b, c]) => {
  console.log(`${a} ${b} ${c}`);
});

Option 2: Using indexes (the common idiomatic approach) #

In JavaScript, using explicit indexes for this kind of sliding window is actually quite standard and idiomatic—especially for simple window sizes like 3. It's straightforward, readable, and avoids extra abstraction overhead:

const foo = ["some", "random", "list", "foo"];
// Iterate only until we can still grab a full triplet
for (let i = 0; i <= foo.length - 3; i++) {
  const a = foo[i];
  const b = foo[i + 1];
  const c = foo[i + 2];
  console.log(`${a} ${b} ${c}`);
}

This is the approach most JS developers would reach for first for one-off tasks—it's direct and requires no extra setup.

Which should you choose? #

• Go with the generator/Array.from approach if you need to reuse the sliding window logic across your codebase, or if you want to keep your main traversal code free of index math.
• Stick with explicit indexes for simple, one-off sliding window work—it's more idiomatic and instantly recognizable to other JavaScript developers.

内容的提问来源于stack exchange，提问作者Kent Shikama