Конкатентные два массива [дубликат]

Не встроен в Javascript. Некоторые из общих фреймворков Javascript (например, Prototype) предоставляют реализацию, или вы можете написать свой собственный.

В дополнение к превосходному и всестороннему ответу ninjagecko все, что требуется, чтобы закрепить два JS-массива в «tuple-mimic»:

//Arrays: aIn, aOut
Array.prototype.map.call( aIn, function(e,i){return [e, aOut[i]];})

Объяснение: Поскольку Javascript не имеет tuples, функции для кортежей, списков и наборов не были высокоприоритетными в спецификации языка. В противном случае подобное поведение доступно простым способом с помощью карты массива в JS> 1,6 . (map на самом деле часто реализуется разработчиками двигателей JS во многих двигателях JS 1.4, несмотря на то, что они не указаны). Основное отличие от zip, izip от Python, ... от функционального стиля map, так как map требует аргумента функции. Кроме того, это функция Array. Вместо этого можно использовать Array.prototype.map, если возникает дополнительная декларация для ввода.

Пример:

_tarrin = [0..constructor, function(){}, false, undefined, '', 100, 123.324,
         2343243243242343242354365476453654625345345, 'sdf23423dsfsdf',
         'sdf2324.234dfs','234,234fsf','100,100','100.100']
_parseInt = function(i){return parseInt(i);}
_tarrout = _tarrin.map(_parseInt)
_tarrin.map(function(e,i,a){return [e, _tarrout[i]]})

Результат:

//'('+_tarrin.map(function(e,i,a){return [e, _tarrout[i]]}).join('),\n(')+')'
>>
(function Number() { [native code] },NaN),
(function (){},NaN),
(false,NaN),
(,NaN),
(,NaN),
(100,100),
(123.324,123),
(2.3432432432423434e+42,2),
(sdf23423dsfsdf,NaN),
(sdf2324.234dfs,NaN),
(234,234fsf,234),
(100,100,100),
(100.100,100)

Связанная производительность:

Использование map над for -loops:

См. . Каков наиболее эффективный способ слияния [1,2] и [7, 8] в [[1,7], [2,8]]

[/g2]

Примечание: базовые типы, такие как false и undefined не обладают прототипной иерархией объектов и, следовательно, не предоставляют функцию toString. Следовательно, они отображаются как пустые в выводе. Поскольку второй аргумент parseInt является базовым / числовым основанием, которому нужно преобразовать число в, и поскольку map передает индекс в качестве второго аргумента своей аргумент-функции, используется функция-обертка.

Еще одна вариация Ddi's :

function* iter(it) {
    yield* it;
}

function* zip(...its) {
    its = its.map(iter);
    while (true) {
        let rs = its.map(it => it.next());
        if (rs.some(r => r.done))
            return;
        yield rs.map(r => r.value);
    }
}

for (let r of zip([1,2,3], [4,5,6,7], [8,9,0,11,22]))
    console.log(r.join())

// the only change for "longest" is some -> every

function* zipLongest(...its) {
    its = its.map(iter);
    while (true) {
        let rs = its.map(it => it.next());
        if (rs.every(r => r.done))
            return;
        yield rs.map(r => r.value);
    }
}

for (let r of zipLongest([1,2,3], [4,5,6,7], [8,9,0,11,22]))
    console.log(r.join())

И вот как написать py classic zip(*[iter(a)]*n) :

triples = [...zip(...Array(3).fill(iter(a)))]

Проверьте библиотеку Underscore .

Underscore предоставляет более 100 функций, которые поддерживают как ваши любимые функциональные помощники workaday: map, filter, invoke - а также больше специализированные лакомства: привязка функций, javascript templating, создание быстрых индексов, глубокое тестирование равенства и т. д.

- скажите людям, которые его сделали

Недавно я начал использовать он специально для функции zip() , и он оставил большое первое впечатление. Я использую jQuery и CoffeeScript, и он отлично сочетается с ними. Подчеркивание поднимается прямо там, где они уходят, и пока это меня не подвело. Кстати, это всего лишь 3kb.

Проверьте это.

Библиотека Mochikit предоставляет эту и многие другие Python-подобные функции. разработчик Mochikit также является поклонником Python, поэтому он имеет общий стиль Python, а также обматывает асинхронные вызовы в скрученной структуре.

pythonic предлагает zip вдоль некоторых других подобных питону функций:

import {zip} from 'pythonic';

const arr1 = ['a', 'b'];
const arr2 = ['c', 'd', 'e'];
for (const [first, second] of zip(arr1, arr2))
    console.log(`first: ${first}, second: ${second}`);
// first: a, second: c
// first: b, second: d

Я попробовал это в чистом JS, задаваясь вопросом, как вышеперечисленные плагины выполнили свою работу. Вот мой результат. Я предопределю это, сказав, что я понятия не имею, насколько стабильным это будет в IE и тому подобное. Это просто быстрый макет.

init();

function init() {
    var one = [0, 1, 2, 3];
    var two = [4, 5, 6, 7];
    var three = [8, 9, 10, 11, 12];
    var four = zip(one, two, one);
    //returns array
    //four = zip(one, two, three);
    //returns false since three.length !== two.length
    console.log(four);
}

function zip() {
    for (var i = 0; i < arguments.length; i++) {
        if (!arguments[i].length || !arguments.toString()) {
            return false;
        }
        if (i >= 1) {
            if (arguments[i].length !== arguments[i - 1].length) {
                return false;
            }
        }
    }
    var zipped = [];
    for (var j = 0; j < arguments[0].length; j++) {
        var toBeZipped = [];
        for (var k = 0; k < arguments.length; k++) {
            toBeZipped.push(arguments[k][j]);
        }
        zipped.push(toBeZipped);
    }
    return zipped;
}

Это не пуленепробиваемый, но это все еще интересно.

Как @Brandon, я рекомендую функцию Underscore zip . Тем не менее, он действует как zip_longest, добавляя значения undefined по мере необходимости, чтобы вернуть что-то длину самого длинного ввода.

Я использовал метод mixin для расширения подчеркивания с помощью zipShortest, который действует как zip Python, основанный на на собственном источнике библиотеки для zip .

Вы можете добавить следующее в свой обычный JS-код, а затем вызвать его так, как если бы он был частью подчеркивания: _.zipShortest([1,2,3], ['a']) возвращает [[1, 'a']], например.

// Underscore library addition - zip like python does, dominated by the shortest list
//  The default injects undefineds to match the length of the longest list.
_.mixin({
    zipShortest : function() {
        var args = Array.Prototype.slice.call(arguments);
        var length = _.min(_.pluck(args, 'length')); // changed max to min
        var results = new Array(length);
        for (var i = 0; i < length; i++) {
            results[i] = _.pluck(args, "" + i);
        }
        return results;
}});

Python имеет две функции: zip и itertools.zip_longest. Реализация на JS / ES6 выглядит так:

Реализация Python `s zip на JS / ES6

const zip = (...arrays) => {
    const length = Math.min(...arrays.map(arr => arr.length));
    return Array.from({ length }, (value, index) => arrays.map((array => array[index])));
};

Результаты:

console.log(zip(
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    [11, 221]
));

[[1, 667, 111, 11]]

console.log(zip(
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111, 212, 323, 433, '1111']
));

[[1, 667, 111], [2, false, 212], [3, -378 , 323], ['a', '337', 433]]

console.log(zip(
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[]

Реализация Python`s zip_longest на JS / ES6

( https://docs.python.org/3.5/library/itertools.html?highlight=zip_longest#itertools.zip_longest )

const zipLongest = (placeholder = undefined, ...arrays) => {
    const length = Math.max(...arrays.map(arr => arr.length));
    return Array.from(
        { length }, (value, index) => arrays.map(
            array => array.length - 1 >= index ? array[index] : placeholder
        )
    );
};

Результаты:

console.log(zipLongest(
    undefined,
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[[1, 667, 111, undefined], [2, false, undefined, undefined], [3, -378, undefined, undefined], ['a', '337', undefined, undefined]]

console.log(zipLongest(
    null,
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[[1, 667, 111, null], [2, false, null, null], [3, -378, null, null], ['a', '337', null, null]]

console.log(zipLongest(
    'Is None',
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[[1 , «Нет», «Нет», «Нет», «2», «Нет», «Нет», [3, -378, «Нет», «Нет»], [ 337 ',' None, 'None']]

Это приведет к отключению ответа на итератор Ddi :

function* zip(...toZip) {
  const iterators = toZip.map((arg) => arg[Symbol.iterator]());
  const next = () => toZip = iterators.map((iter) => iter.next());
  while (next().every((item) => !item.done)) {
    yield toZip.map((item) => item.value);
  }
}

  const zip = (arr,...arrs)=>arr.map((v,i)=>arrs.reduce((a,arr)=>[...a, arr[i]], [v]))

Современный пример ES6 с генератором:

function *zip (...iterables){
    let iterators = iterables.map(i => i[Symbol.iterator]() )
    while (true) {
        let results = iterators.map(iter => iter.next() )
        if (results.some(res => res.done) ) return
        else yield results.map(res => res.value )
    }
}

Сначала мы получаем список итераций как iterators. Обычно это происходит прозрачно, но здесь мы делаем это явно, поскольку мы даем шаг за шагом, пока один из них не исчерпан. Мы проверяем, исчерпан ли какой-либо из результатов (с использованием метода .some()) в заданном массиве, и если это так, мы прерываем цикл while.