Hợp nhất hai mảng với xen kẽ Values ​​

Question

tôi muốn kết hợp 2 mảng với chiều dài khác nhau:

let array2 = ["a", "b", "c", "d"]; 
let array2 = [1, 2]; 

let outcome = ["a",1 ,"b", 2, "c", "d"] 

Whats cách tốt nhất để làm điều đó?

Edit: Kết quả tôi mong chờ là ["a", 1 ,"b", 2, "c", "d"]

Answer 1

Bạn có thể lặp lại theo chiều dài tối thiểu của cả hai mảng và xây dựng các yếu tố thay thế và cuối cùng đẩy phần còn lại.

var array1 = ["a", "b", "c", "d"], 
 
    array2 = [1, 2], 
 
    result = [], 
 
    i, l = Math.min(array1.length, array2.length); 
 
    
 
for (i = 0; i < l; i++) { 
 
    result.push(array1[i], array2[i]); 
 
} 
 
result.push(...array1.slice(l), ...array2.slice(l)); 
 

 
console.log(result);

Giải pháp cho một số tùy ý các mảng với một thuật toán transposing và sau đó làm phẳng.

var array1 = ["a", "b", "c", "d"], 
 
    array2 = [1, 2], 
 
    result = [array1, array2] 
 
     .reduce((r, a) => (a.forEach((a, i) => (r[i] = r[i] || []).push(a)), r), []) 
 
     .reduce((a, b) => a.concat(b)); 
 
    
 
console.log(result);

Answer 2

Tạo một mảng của các bộ. Mỗi tuple chứa 1 phần tử từ mỗi mảng, san bằng cách quảng bá các mảng của các bộ, và thêm các mục còn sót lại từ các mảng:

const a1 = ["a", "b", "c", "d"]; 
 
const a2 = [1,2]; 
 
const l = Math.min(a1.length, a2.length); 
 

 
const merged = [].concat(...Array.from({ length: l }, (_, i) => [a1[i], a2[i]]), a1.slice(l), a2.slice(l)); 
 
    
 
console.log(merged);

Answer 3

Dưới đây là một cách khác để bạn có thể làm điều đó bằng destructuring phân

const interleave = ([x,...xs], [y,...ys]) => 
 
    x === undefined && y === undefined 
 
    ? [] 
 
    : x === undefined 
 
     ? [y] .concat (ys) 
 
     : y === undefined 
 
     ? [x] .concat (xs) 
 
     : [x, y] .concat (interleave (xs, ys)) 
 
    
 

 
console.log (interleave ([0, 2, 4, 6], [1, 3, 5])) // [ 0 1 2 3 4 5 6 ]  
 
console.log (interleave ([0, 2, 4], [1, 3, 5, 7])) // [ 0 1 2 3 4 5 7 ] 
 
console.log (interleave ([0, 2, 4], []))   // [ 0 2 4 ] 
 
console.log (interleave ([], [1, 3, 5, 7]))  // [ 1 3 5 7 ] 
 
console.log (interleave ([], []))     // [ ]

Và ở đây nó được sử dụng một cái đuôi thích hợp gọi

const interleave = ([x,...xs], [y,...ys], acc = []) => 
 
    x === undefined && y === undefined 
 
    ? acc 
 
    : x === undefined 
 
     ? acc.concat (y, ys) 
 
     : y === undefined 
 
     ? acc.concat (x, xs) 
 
     : interleave (xs, ys, acc.concat ([x, y])) 
 

 
console.log (interleave ([0, 2, 4, 6], [1, 3, 5])) // [ 0 1 2 3 4 5 6 ]  
 
console.log (interleave ([0, 2, 4], [1, 3, 5, 7])) // [ 0 1 2 3 4 5 7 ] 
 
console.log (interleave ([0, 2, 4], []))   // [ 0 2 4 ] 
 
console.log (interleave ([], [1, 3, 5, 7]))  // [ 1 3 5 7 ] 
 
console.log (interleave ([], []))     // [ ]

Và một lần nữa mà không sử dụng destructuring phân

const interleave = (xs, ys, acc = []) => 
 
    xs.length === 0 && ys.length === 0 
 
    ? acc 
 
    : xs.length === 0 
 
     ? acc.concat (ys) 
 
     : ys.length === 0 
 
     ? acc.concat (xs) 
 
     : interleave (xs.slice (1), ys.slice (1), acc.concat ([xs[0], ys[0]])) 
 

 
console.log (interleave ([0, 2, 4, 6], [1, 3, 5])) // [ 0 1 2 3 4 5 6 ] 
 
console.log (interleave ([0, 2, 4], [1, 3, 5, 7])) // [ 0 1 2 3 4 5 7 ] 
 
console.log (interleave ([0, 2, 4], []))   // [ 0 2 4 ] 
 
console.log (interleave ([], [1, 3, 5, 7]))  // [ 1 3 5 7 ] 
 
console.log (interleave ([], []))     // [ ]

Hoặc một sự kết hợp của các cuộc gọi đuôi và chỉ số của bạn - cái này là nhanh nhất so với các đoạn khác tôi đã được cung cấp vì nó phân bổ ít nhất, tạo ra các giá trị trung gian ít nhất, và do đó ít rác thải sau tính toán hơn bộ sưu tập - thắng/thắng/thắng

const interleave = (xs, ys, i = 0, acc = []) => 
 
    xs.length === i && ys.length === i 
 
    ? acc 
 
    : xs.length === i 
 
     ? acc.concat (ys.slice (i)) 
 
     : ys.length === i 
 
     ? acc.concat (xs.slice (i)) 
 
     : interleave (xs, ys, i + 1, acc.concat ([xs[i], ys[i]])) 
 

 
console.log (interleave ([0, 2, 4, 6], [1, 3, 5])) // [ 0 1 2 3 4 5 6 ] 
 
console.log (interleave ([0, 2, 4], [1, 3, 5, 7])) // [ 0 1 2 3 4 5 7 ] 
 
console.log (interleave ([0, 2, 4], []))   // [ 0 2 4 ] 
 
console.log (interleave ([], [1, 3, 5, 7]))  // [ 1 3 5 7 ] 
 
console.log (interleave ([], []))     // [ ]

Các quan tâm sẽ nhận thấy rằng i và acc đang bị rò rỉ API riêng - điều này có thể dễ dàng khắc phục bằng cách sử dụng helper loop; lưu ý kỹ thuật này cũng làm cho interleave stack-an toàn trong một tổ chức phi-đuôi-gọi-tối ưu hóa môi trường

Vì vậy, so với ở trên, chúng tôi nhận hai hơn thắng, làm cho này thắng/thắng/thắng/thắng/thắng

const recur = (...values) => 
 
    ({ type: recur, values }) 
 
    
 
const loop = f => 
 
    { 
 
    let acc = f() 
 
    while (acc && acc.type === recur) 
 
     acc = f (...acc.values) 
 
    return acc 
 
    } 
 

 
const interleave = (xs, ys) => 
 
    loop ((i = 0, acc = []) => 
 
    xs.length === i && ys.length === i 
 
     ? acc 
 
     : xs.length === i 
 
     ? acc.concat (ys.slice (i)) 
 
     : ys.length === i 
 
      ? acc.concat (xs.slice (i)) 
 
      : recur (i + 1, acc.concat ([xs[i], ys[i]]))) 
 

 
console.log (interleave ([0, 2, 4, 6], [1, 3, 5])) // [ 0 1 2 3 4 5 6 ] 
 
console.log (interleave ([0, 2, 4], [1, 3, 5, 7])) // [ 0 1 2 3 4 5 7 ] 
 
console.log (interleave ([0, 2, 4], []))   // [ 0 2 4 ] 
 
console.log (interleave ([], [1, 3, 5, 7]))  // [ 1 3 5 7 ] 
 
console.log (interleave ([], []))     // [ ]