Zip-Arrays in JavaScript?

Question 1

Ich habe 2 Arrays:

var a = [1, 2, 3]
var b = [a, b, c]

Was ich als Ergebnis erhalten möchte ist:

[[1, a], [2, b], [3, c]]

Es scheint einfach, aber ich kann einfach nicht herausfinden.

Ich möchte, dass das Ergebnis ein Array ist, in dem jedes der Elemente aus den beiden Arrays zusammengezippt ist.

Question 2

Verwenden Sie die map Methode:

var a = [1, 2, 3]
var b = ['a', 'b', 'c']

var c = a.map(function(e, i) {
  return [e, b[i]];
});

console.log(c)

DEMO

Question 3

Zip-Arrays von die gleiche Länge:

Verwenden Array.prototype.map()

const zip = (a, b) => a.map((k, i) => [k, b[i]]);

console.log(zip([1,2,3], ["a","b","c"]));
// [[1, "a"], [2, "b"], [3, "c"]]

Zip-Arrays unterschiedlicher Länge:

Verwenden Array.from()

const zip = (a, b) => Array.from(Array(Math.max(b.length, a.length)), (_, i) => [a[i], b[i]]);

console.log( zip([1,2,3], ["a","b","c","d"]) );
// [[1, "a"], [2, "b"], [3, "c"], [undefined, "d"]]

Verwenden Array.prototype.fill() Und Array.prototype.map()

const zip = (a, b) => Array(Math.max(b.length, a.length)).fill().map((_,i) => [a[i], b[i]]);

console.log(zip([1,2,3], ["a","b","c","d"]));
// [[1, "a"], [2, "b"], [3, "c"], [undefined, "d"]]

Mehrere Zips (N) Arrays:

const zip = (...arr) => Array(Math.max(...arr.map(a => a.length))).fill().map((_,i) => arr.map(a => a[i]));  
console.log(zip([1,2], [3,4], [5,6])); // [[1,3,5], [2,4,6]]

Question 4

Zippen durch Nutzung von Generatorfunktionen

Sie können auch eine verwenden Generatorfunktion Zu zip().

const a = [1, 2, 3]
const b = ['a', 'b', 'c']

/**
 * Zips any number of arrays. It will always zip() the largest array returning undefined for shorter arrays.
 * @param  {...Array<any>} arrays 
 */
function* zip(...arrays){
  const maxLength = arrays.reduce((max, curIterable) => curIterable.length > max ? curIterable.length: max, 0);
  for (let i = 0; i < maxLength; i++) {
    yield arrays.map(array => array[i]);
  }
}

// put zipped result in an array
const result = [...zip(a, b)]

// or lazy generate the values
for (const [valA, valB] of zip(a, b)) {
  console.log(`${valA}: ${valB}`);  
}

.as-console-wrapper { max-height: 100% !important; top: 0; }

Das obige funktioniert für eine beliebige Anzahl von Arrays und wird zip() das längste Array so undefined wird als Wert für kürzere Arrays zurückgegeben.

Reißverschluss von allen `Iterables`

Hier eine Funktion die für alle nutzbar ist Iterables (z.B Maps, Sets oder Ihre Gewohnheit Iterable), nicht nur Arrays.

const a = [1, 2, 3];
const b = ["a", "b", "c"];

/**
 * Zips any number of iterables. It will always zip() the largest Iterable returning undefined for shorter arrays.
 * @param  {...Iterable<any>} iterables
 */
function* zip(...iterables) {
  // get the iterator of for each iterables
  const iters = [...iterables].map((iterable) => iterable[Symbol.iterator]());
  let next = iters.map((iter) => iter.next().value);
  // as long as any of the iterables returns something, yield a value (zip longest)
  while(anyOf(next)) {
    yield next;
    next = iters.map((iter) => iter.next().value);
  }

  function anyOf(arr){
    return arr.some(v => v !== undefined);
  }
}

// put zipped result in aa array
const result = [...zip(a, new Set(b))];

// or lazy generate the values
for (const [valA, valB] of zip(a, new Set(b))) {
  console.log(`${valA}: ${valB}`);
}

Natürlich wäre es auch möglich, nur zu verwenden [...Iterable] irgendwelche umzuwandeln Iterable zu einem Array und verwenden Sie dann die erste Funktion.

Question 5

Verwendung der reduce Methode:

const a = [1, 2, 3]
const b = ['a', 'b', 'c']

var c = a.reduce((acc, curr, ind) => {
  acc.push([curr, b[ind]]);
  return acc;
}, []);
console.log(c)

Mit forEach Methode:

const a = [1, 2, 3]
const b = ['a', 'b', 'c']
const c = [];
a.forEach((el, ind) => {
    c.push([el, b[ind]])
});
console.log(c)

Question 6

Bereitstellung einer Lösung mit zwingender Programmierung auf einfache Weise for loop.

Dies funktioniert besser, wenn Sie dies tun Reißverschluss Betrieb an riesig Daten Sets im Vergleich zu den bequemen Array-Funktionen wie map() Und forEach().

Beispiel:

const a = [1, 2, 3];
const b = ['a', 'b', 'c'];
const result = [];
for (let i = 0; i < a.length; i++) {
  result.push([a[i], b[i]]);
}
console.log(result);

Und wenn Sie eine 1-Linie wollen einfacher Lösung dann können Sie eine Bibliothek wie verwenden Ramda das hat ein Reißverschluss Funktion.