Javascript tương đương với chức năng zip của Python

Có một javascript tương đương với chức năng zip của Python không? Nghĩa là, cho nhiều mảng có độ dài bằng nhau tạo ra một mảng các cặp.

Chẳng hạn, nếu tôi có ba mảng trông như thế này:

var array1 = [1, 2, 3];
var array2 = ['a','b','c'];
var array3 = [4, 5, 6];

Mảng đầu ra phải là:

var output array:[[1,'a',4], [2,'b',5], [3,'c',6]]

Cập nhật năm 2016:

Đây là phiên bản Ecmascript 6 snazzier:

zip= rows=>rows[0].map((_,c)=>rows.map(row=>row[c]))

Minh họa tương đương. tới Python { zip(*args)}:

> zip([['row0col0', 'row0col1', 'row0col2'],
       ['row1col0', 'row1col1', 'row1col2']]);
[["row0col0","row1col0"],
 ["row0col1","row1col1"],
 ["row0col2","row1col2"]]

(và FizzyTea chỉ ra rằng ES6 có cú pháp luận variadic, vì vậy định nghĩa hàm sau đây sẽ đóng vai trò như trăn, nhưng xem dưới đây để từ chối trách nhiệm ... điều này sẽ không được nghịch đảo của riêng mình nên zip(zip(x))sẽ không bằng nhau x, mặc dù như Matt Kramer chỉ ra zip(...zip(...x))==x(như trong trăn thường xuyên zip(*zip(*x))==x))

Định nghĩa thay thế tương đương. tới Python { zip}:

> zip = (...rows) => [...rows[0]].map((_,c) => rows.map(row => row[c]))
> zip( ['row0col0', 'row0col1', 'row0col2'] ,
       ['row1col0', 'row1col1', 'row1col2'] );
             // note zip(row0,row1), not zip(matrix)
same answer as above

(Xin lưu ý rằng ...cú pháp có thể có vấn đề về hiệu suất tại thời điểm này và có thể trong tương lai, vì vậy nếu bạn sử dụng câu trả lời thứ hai với các đối số có lỗi, bạn có thể muốn kiểm tra hoàn hảo nó.)

Đây là một oneliner:

function zip(arrays) {
    return arrays[0].map(function(_,i){
        return arrays.map(function(array){return array[i]})
    });
}

// > zip([[1,2],[11,22],[111,222]])
// [[1,11,111],[2,22,222]]]

// If you believe the following is a valid return value:
//   > zip([])
//   []
// then you can special-case it, or just do
//  return arrays.length==0 ? [] : arrays[0].map(...)

Các giả định ở trên cho rằng các mảng có kích thước bằng nhau, như chúng phải vậy. Nó cũng giả sử bạn vượt qua trong một danh sách các đối số danh sách, không giống như phiên bản của Python trong đó danh sách đối số là matrixdic. Nếu bạn muốn tất cả các "tính năng" này, xem bên dưới. Chỉ mất khoảng 2 dòng mã.

Phần sau đây sẽ bắt chước ziphành vi của Python trong các trường hợp cạnh trong đó các mảng không có kích thước bằng nhau, âm thầm giả vờ các phần dài hơn của mảng không tồn tại:

function zip() {
    var args = [].slice.call(arguments);
    var shortest = args.length==0 ? [] : args.reduce(function(a,b){
        return a.length<b.length ? a : b
    });

    return shortest.map(function(_,i){
        return args.map(function(array){return array[i]})
    });
}

// > zip([1,2],[11,22],[111,222,333])
// [[1,11,111],[2,22,222]]]

// > zip()
// []

Điều này sẽ bắt chước itertools.zip_longesthành vi của Python , chèn vào undefinednơi các mảng không được xác định:

function zip() {
    var args = [].slice.call(arguments);
    var longest = args.reduce(function(a,b){
        return a.length>b.length ? a : b
    }, []);

    return longest.map(function(_,i){
        return args.map(function(array){return array[i]})
    });
}

// > zip([1,2],[11,22],[111,222,333])
// [[1,11,111],[2,22,222],[null,null,333]]

// > zip()
// []

Nếu bạn sử dụng hai phiên bản cuối cùng này (matrixdic aka. Phiên bản nhiều đối số), thì zip không còn là nghịch đảo của chính nó. Để bắt chước zip(*[...])thành ngữ từ Python, bạn sẽ cần phải làm zip.apply(this, [...])khi bạn muốn đảo ngược chức năng zip hoặc nếu bạn muốn có một số lượng danh sách khác nhau làm đầu vào.

phụ lục :

Để làm cho điều này xử lý bất kỳ lần lặp nào (ví dụ: trong Python bạn có thể sử dụng ziptrên chuỗi, phạm vi, đối tượng bản đồ, v.v.), bạn có thể định nghĩa như sau:

function iterView(iterable) {
    // returns an array equivalent to the iterable
}

Tuy nhiên, nếu bạn viết ziptheo cách sau , thậm chí điều đó sẽ không cần thiết:

function zip(arrays) {
    return Array.apply(null,Array(arrays[0].length)).map(function(_,i){
        return arrays.map(function(array){return array[i]})
    });
}

Bản giới thiệu:

> JSON.stringify( zip(['abcde',[1,2,3,4,5]]) )
[["a",1],["b",2],["c",3],["d",4],["e",5]]

(Hoặc bạn có thể sử dụng range(...)hàm kiểu Python nếu bạn đã viết một hàm. Cuối cùng, bạn sẽ có thể sử dụng các trình hiểu hoặc trình tạo mảng ECMAScript.)

Kiểm tra thư viện gạch dưới .

Underscore cung cấp hơn 100 chức năng hỗ trợ cả những người trợ giúp chức năng yêu thích của bạn: map, filter, invoke - cũng như các tính năng chuyên biệt hơn: liên kết chức năng, tạo khuôn mẫu javascript, tạo chỉ mục nhanh, kiểm tra công bằng sâu, v.v.

- Nói những người đã làm nó

Gần đây tôi đã bắt đầu sử dụng nó đặc biệt cho zip()chức năng và nó đã để lại ấn tượng đầu tiên tuyệt vời. Tôi đang sử dụng jQuery và CoffeeScript và nó hoàn toàn phù hợp với họ. Underscore nhặt lên ngay tại nơi họ rời đi và cho đến nay nó đã không làm tôi thất vọng. À nhân tiện, nó chỉ giảm 3kb.

Kiểm tra xem nó:

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
// returns [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]

Ngoài câu trả lời xuất sắc và toàn diện của ninjagecko, tất cả những gì cần có để nén hai mảng JS thành một "tuple-mimic" là:

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

Giải thích:
Vì Javascript không có tuplesloại, các hàm cho bộ dữ liệu, danh sách và bộ không phải là ưu tiên cao trong đặc tả ngôn ngữ.
Mặt khác, hành vi tương tự có thể truy cập theo cách đơn giản thông qua bản đồ Mảng trong JS> 1.6 . ( mapthực tế thường được các nhà sản xuất công cụ JS triển khai trong nhiều công cụ> JS 1.4, mặc dù không được chỉ định).
Sự khác biệt lớn đối với Python zip, izip... kết quả từ mapphong cách chức năng 's, vì mapđòi hỏi một hàm có đối số. Ngoài ra, nó là một chức năng của Array-instance. Người ta có thể sử dụng Array.prototype.mapthay thế, nếu một tuyên bố thêm cho đầu vào là một vấn đề.

Thí dụ:

_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]]})

Kết quả:

//'('+_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)

Hiệu suất liên quan:

Sử dụng maptrên for-loops:

Xem: Cách hợp nhất hiệu quả nhất [1,2] và [7,8] thành [[1,7], [2,8]]

Lưu ý: các loại cơ sở như falsevà undefinedkhông đặt ra một hệ thống phân cấp đối tượng nguyên mẫu và do đó không làm lộ ra một toStringchức năng. Do đó chúng được hiển thị là trống trong đầu ra.
Vì parseIntđối số thứ hai là cơ số / số cơ sở, để chuyển đổi số thành và từ đó mapchuyển chỉ mục làm đối số thứ hai sang hàm đối số của nó, nên sử dụng hàm bao bọc.

Ví dụ ES6 hiện đại với một trình tạo:

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 )
    }
}

Đầu tiên, chúng ta có một danh sách các lần lặp như iterators. Điều này thường xảy ra một cách minh bạch, nhưng ở đây chúng tôi làm điều đó một cách rõ ràng, khi chúng tôi nhường từng bước cho đến khi một trong số chúng bị cạn kiệt. Chúng tôi kiểm tra xem có bất kỳ kết quả nào (sử dụng .some()phương thức) trong mảng đã cho không, và nếu vậy, chúng tôi sẽ phá vỡ vòng lặp while.

Cùng với các hàm giống như Python khác, pythoniccung cấp một ziphàm, với lợi ích bổ sung là trả về một kẻ lười biếng được đánh giá Iterator, tương tự như hành vi của đối tác Python của nó :

import {zip, zipLongest} 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

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

// unzip
const [arrayFirst, arraySecond] = [...zip(...zip(arr1, arr2))];

Tiết lộ Tôi là tác giả và người duy trì Pythonic

Python có hai hàm: zip và itertools.zip_longest. Việc triển khai trên JS / ES6 là như thế này:

Triển khai mã zip của Python trên 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])));
};

Các kết quả:

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, sai, 212], [3, -378, 323], ['a', '337', 433]

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

[]

Triển khai Python `zip_longest trên JS / ES6

( https://docs.python.org/3.5/lvern/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
        )
    );
};

Các kết quả:

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

[[1, 667, 111, không xác định], [2, sai, không xác định, không xác định],
[3, -378, không xác định, không xác định], ['a', '337', không xác định, không xác định]]

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

[[1, 667, 111, null], [2, sai, 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, 667, 111, 'Is none'], [2, false, 'Is none', 'Is none'],
[3, -378, 'Is none', 'Is none'], ['a ',' 337 ',' Is none ',' Is none ']]

Bạn có thể thực hiện chức năng tiện ích bằng cách sử dụng ES6.

const zip = (arr, ...arrs) => {
  return arr.map((val, i) => arrs.reduce((a, arr) => [...a, arr[i]], [val]));
}

// example

const array1 = [1, 2, 3];
const array2 = ['a','b','c'];
const array3 = [4, 5, 6];

console.log(zip(array1, array2));                  // [[1, 'a'], [2, 'b'], [3, 'c']]
console.log(zip(array1, array2, array3));          // [[1, 'a', 4], [2, 'b', 5], [3, 'c', 6]]

Tuy nhiên, trong độ dài giải pháp trên của mảng đầu tiên xác định độ dài của mảng đầu ra.

Đây là giải pháp mà bạn có nhiều quyền kiểm soát hơn. Nó hơi phức tạp nhưng đáng giá.

function _zip(func, args) {
  const iterators = args.map(arr => arr[Symbol.iterator]());
  let iterateInstances = iterators.map((i) => i.next());
  ret = []
  while(iterateInstances[func](it => !it.done)) {
    ret.push(iterateInstances.map(it => it.value));
    iterateInstances = iterators.map((i) => i.next());
  }
  return ret;
}
const array1 = [1, 2, 3];
const array2 = ['a','b','c'];
const array3 = [4, 5, 6];

const zipShort = (...args) => _zip('every', args);

const zipLong = (...args) => _zip('some', args);

console.log(zipShort(array1, array2, array3)) // [[1, 'a', 4], [2, 'b', 5], [3, 'c', 6]]
console.log(zipLong([1,2,3], [4,5,6, 7]))
// [
//  [ 1, 4 ],
//  [ 2, 5 ],
//  [ 3, 6 ],
//  [ undefined, 7 ]]

1. Mô-đun Npm: zip-array

Tôi tìm thấy một mô-đun npm có thể được sử dụng như một phiên bản javascript của python zip:

zip-Array - Tương đương javascript của hàm zip của Python. Hợp nhất các giá trị của từng mảng.

https://www.npmjs.com/package/zip-array

2. tf.data.zip() trong Tensorflow.js

Một lựa chọn thay thế khác là dành cho người dùng Tensorflow.js: nếu bạn cần zip hàm trong python để làm việc với các bộ dữ liệu hàng chục trong Javascript, bạn có thể sử dụng tf.data.zip()trong Tensorflow.js.

tf.data.zip () trong Tensorflow.js được ghi lại ở đây

Không tích hợp sẵn vào Javascript. Một số khung Javascript phổ biến (như Prototype) cung cấp triển khai hoặc bạn có thể tự viết.

Giống như @Brandon, tôi khuyên dùng chức năng zip của Underscore . Tuy nhiên, nó hoạt động như , nối thêmzip_longestundefined các giá trị khi cần thiết để trả về thứ gì đó có độ dài của đầu vào dài nhất.

Tôi đã sử dụng mixinphương pháp để mở rộng dấu gạch dưới với một zipShortest, hoạt động như của Python zip, dựa trên nguồn riêng của thư viện chozip .

Bạn có thể thêm những điều sau đây để mã JS chung của bạn và sau đó gọi nó như thể nó là một phần của gạch: _.zipShortest([1,2,3], ['a'])lợi nhuận [[1, 'a']], ví dụ.

// 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;
}});

Bạn có thể giảm mảng của mảng và ánh xạ mảng mới bằng cách lấy kết quả của chỉ mục của mảng bên trong.

var array1 = [1, 2, 3],
    array2 = ['a','b','c'],
    array3 = [4, 5, 6],
    array = [array1, array2, array3],
    transposed = array.reduce((r, a) => a.map((v, i) => (r[i] || []).concat(v)), []);

console.log(transposed);

Một biến thể của giải pháp máy phát lười biếng :

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())

Và đây là thành ngữ "nhóm n" kinh điển của trăn zip(*[iter(a)]*n):

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

Các MochiKit thư viện cung cấp này và nhiều người khác Python giống như chức năng. nhà phát triển của Mochikit cũng là một người hâm mộ Python, do đó, nó có phong cách chung của Python và cũng bao bọc các cuộc gọi async trong một khung giống như xoắn.

Tôi đã thực hiện điều này trong JS thuần túy tự hỏi làm thế nào các plugin được đăng ở trên đã hoàn thành công việc. Đây là kết quả của tôi. Tôi sẽ mở đầu điều này bằng cách nói rằng tôi không biết điều này sẽ ổn định như thế nào trong IE và tương tự. Nó chỉ là một mockup nhanh chóng.

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;
}

Nó không chống đạn, nhưng nó vẫn thú vị.

Điều này loại bỏ một dòng khỏi câu trả lời dựa trên iterator của 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);
  }
}

Nếu bạn ổn với ES6:

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