Cách hiệu quả nhất để thêm một giá trị vào một mảng

Giả sử tôi có một mảng có kích thước N(ở đâu N > 0), có cách nào hiệu quả hơn để chuẩn bị cho mảng không yêu cầu các bước O (N + 1) không?

Về mã, về cơ bản, những gì tôi hiện đang làm là

function prependArray(value, oldArray) {
  var newArray = new Array(value);

  for(var i = 0; i < oldArray.length; ++i) {
    newArray.push(oldArray[i]);
  }

  return newArray;
}

Tôi không chắc về hiệu quả hơn về mặt big-O nhưng chắc chắn sử dụng unshiftphương pháp này ngắn gọn hơn:

var a = [1, 2, 3, 4];
a.unshift(0);
a; // => [0, 1, 2, 3, 4]

[Biên tập]

Điểm chuẩn jsPerf này cho thấy unshifttốc độ nhanh hơn trong ít nhất một vài trình duyệt, bất kể hiệu suất big-O có thể khác nhau nếu bạn đồng ý với việc sửa đổi mảng tại chỗ. Nếu bạn thực sự không thể thay đổi mảng ban đầu thì bạn sẽ làm một cái gì đó như đoạn mã dưới đây, dường như không nhanh hơn giải pháp của bạn:

a.slice().unshift(0); // Use "slice" to avoid mutating "a".

[Chỉnh sửa 2]

Để hoàn thiện, có thể sử dụng hàm sau thay cho ví dụ của OP prependArray(...)để tận dụng unshift(...)phương thức Array :

function prepend(value, array) {
  var newArray = array.slice();
  newArray.unshift(value);
  return newArray;
}

var x = [1, 2, 3];
var y = prepend(0, x);
y; // => [0, 1, 2, 3];
x; // => [1, 2, 3];

Với ES6, giờ đây bạn có thể sử dụng toán tử trải rộng để tạo một mảng mới với các phần tử mới của bạn được chèn trước các phần tử gốc.

// Prepend a single item.
const a = [1, 2, 3];
console.log([0, ...a]);

// Prepend an array.
const a = [2, 3];
const b = [0, 1];
console.log([...b, ...a]);

Cập nhật 2018-08-17: Hiệu suất

Tôi dự định câu trả lời này để trình bày một cú pháp thay thế mà tôi nghĩ là dễ nhớ và súc tích hơn. Cần lưu ý rằng theo một số điểm chuẩn (xem câu trả lời khác này ), cú pháp này chậm hơn đáng kể. Điều này có lẽ sẽ không quan trọng trừ khi bạn đang thực hiện nhiều thao tác này trong một vòng lặp.

Nếu bạn đang chuẩn bị một mảng ở phía trước của một mảng khác, thì chỉ cần sử dụng sẽ hiệu quả hơn concat. Vì thế:

var newArray = values.concat(oldArray);

Nhưng đây vẫn sẽ là O (N) trong kích thước của oldArray. Tuy nhiên, nó hiệu quả hơn so với việc lặp lại thủ công trên oldArray. Ngoài ra, tùy thuộc vào các chi tiết, nó có thể giúp bạn, bởi vì nếu bạn định trả trước nhiều giá trị, tốt hơn hết là đặt chúng vào một mảng trước và sau đó ghép oldArray vào cuối, thay vì trả trước từng giá trị riêng lẻ.

Không có cách nào để làm tốt hơn O (N) về kích thước của oldArray, bởi vì các mảng được lưu trữ trong bộ nhớ liền kề với phần tử đầu tiên ở một vị trí cố định. Nếu bạn muốn chèn trước phần tử đầu tiên, bạn cần di chuyển tất cả các phần tử khác. Nếu bạn cần một cách giải quyết vấn đề này, hãy làm những gì @GWW đã nói và sử dụng danh sách được liên kết hoặc cấu trúc dữ liệu khác.

Nếu bạn muốn thêm vào mảng (a1 với mảng a2), bạn có thể sử dụng như sau:

var a1 = [1, 2];
var a2 = [3, 4];
Array.prototype.unshift.apply(a1, a2);
console.log(a1);
// => [3, 4, 1, 2]

f bạn cần giữ nguyên mảng cũ, cắt mảng cũ và chuyển (các) giá trị mới sang đầu lát.

var oldA=[4,5,6];
newA=oldA.slice(0);
newA.unshift(1,2,3)

oldA+'\n'+newA

/*  returned value:
4,5,6
1,2,3,4,5,6
*/

Tôi có một số thử nghiệm mới về các phương pháp chuẩn bị khác nhau. Đối với các mảng nhỏ (<1000 elems), nhà lãnh đạo dành cho chu trình kết hợp với phương pháp đẩy. Đối với các mảng lớn, phương pháp Unshift trở thành người dẫn đầu.

Nhưng tình huống này chỉ thực sự dành cho trình duyệt Chrome. Trong Firefox unshift có một tối ưu hóa tuyệt vời và nhanh hơn trong mọi trường hợp.

ES6 lây lan chậm hơn 100 lần trong tất cả các trình duyệt.

https://jsbench.me/cgjfc79bgx/1

Có một phương pháp đặc biệt:

a.unshift(value);

Nhưng nếu bạn muốn thêm một số phần tử vào mảng thì sẽ nhanh hơn khi sử dụng phương thức như vậy:

var a = [1, 2, 3],
    b = [4, 5];

function prependArray(a, b) {
    var args = b;
    args.unshift(0);
    args.unshift(0);
    Array.prototype.splice.apply(a, args);
}

prependArray(a, b);
console.log(a); // -> [4, 5, 1, 2, 3]

Ví dụ về việc chuẩn bị tại chỗ:

var A = [7,8,9]
var B = [1,2,3]

A.unshift(...B)

console.log(A) // [1,2,3,7,8,9]

Gọi unshiftchỉ trả về độ dài của mảng mới. Vì vậy, để thêm một phần tử vào đầu và trả về một mảng mới, tôi đã làm điều này:

let newVal = 'someValue';
let array = ['hello', 'world'];
[ newVal ].concat(array);

hoặc đơn giản với toán tử trải rộng:

[ newVal, ...array ]

Bằng cách này, mảng ban đầu vẫn còn nguyên.