Вот простая статья о некоторых советах по использованию массивов JavaScript. Мы будем использовать различные методы для объединения/объединения двух массивов JS, а также обсудить преимущества/недостатки каждого метода.
Сначала рассмотрим следующую ситуацию:
Кода -копия выглядит следующим образом:
var a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var b = ["foo", "bar", "baz", "bam", "bun", "веселье"];
Очевидно, что самый простой результат комбинации должен быть:
Кода -копия выглядит следующим образом:
[
1, 2, 3, 4, 5, 6, 7, 8, 9,
«Foo», «Bar», «Баз», «Бам» «Бун», «Веселье»
]
concat (..)
Это самая распространенная практика:
Кода -копия выглядит следующим образом:
var c = a.concat (b);
а; // [1,2,3,4,5,6,7,8,9]
б; // ["foo", "bar", "baz", "bam", "Bun", "Fun"]
c; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
Как вы можете видеть, C - это совершенно новый массив, который представляет собой комбинацию двух массивов A и B и сохраняет инвариант A и B. Простой?
Но если у A есть 10 000 элементов, а у B имеет 10 000 элементов? C будет иметь 20 000 элементов, поэтому использование памяти A и B удвоится.
"Без проблем!" Вы сказали. Пусть они собираются мусор, установите A и B в NULL, проблема решена!
a = b = null; // 'a' и 'b' переработаны
хе -хе. Для небольших массивов с несколькими элементами это нормально. Но для больших массивов или систем с ограниченной памятью этот процесс должен часто повторять, на самом деле он имеет много улучшений.
Вставка петли
ОК, давайте скопируем содержимое одного массива другому, используя: массив#push (..)
Кода -копия выглядит следующим образом:
// `b` на` a`
for (var i = 0; i <b.length; i ++) {
A.Push (B [i]);
}
а; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
b = null;
Теперь массив A имеет содержимое массива b.
Кажется, есть лучший след памяти.
Но что, если массив А меньше? По причинам памяти и скорости вы можете поместить меньше A перед B,. Нет проблем, просто измените толчок (..) на непрерывное (..):
Кода -копия выглядит следующим образом:
// `a` в` b`:
for (var i = a.length-1; i> = 0; i--) {
B. unhift (A [i]);
}
б; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
Функциональные навыки
Тем не менее, для петли действительно уродливая и трудно поддерживать. Можем ли мы сделать лучше?
Это наша первая попытка, используя массив#уменьшить:
Кода -копия выглядит следующим образом:
// `b` на` a`:
a = b.reduce (function (coll, item) {
coll.push (item);
вернуть колл;
}, а);
а; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
// или `a` в` b`:
b = a.Reduceright (function (coll, item) {
coll.unshift (item);
вернуть колл;
}, b);
б; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
Массив#уменьшить (..) и массив#Reduceright (..) хорош, но они немного неуклюжи. Функция стрелки ES6 => уменьшит количество кода, но она все еще требует функции, и каждый элемент должен быть назван один раз, что не идеально.
Так как насчет этого:
Кода -копия выглядит следующим образом:
// `b` на` a`:
a.push.apply (a, b);
а; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
// или `a` в` b`:
b.unshift.apply (b, a);
б; // [1,2,3,4,5,6,7,8,9, "foo", "bar", "baz", "bam", "Bun", "Fun"]
Это гораздо лучше? Тем более, что непревзойденное (..) метод не должен беспокоиться о предыдущей обратной сортировке здесь. Речевая операция ES6 будет красивее: a.push (... b) или b.unshift (...
Максимальный предел длины для массива
Первая серьезная проблема заключается в том, что использование памяти удваивается (конечно, только временное!) - это в основном копирование элементов в стек с помощью функциональных вызовов. Кроме того, различные двигатели JS имеют ограничения на продолжительность данных копирования.
Таким образом, если у массива есть миллион элементов, вы определенно вы будете за пределами, который подталкивает (...) или непрерывное (...), позволяет стек вызовов. Увы, это сделает большую работу по обработке тысяч элементов, но вы должны быть осторожны, чтобы не превышать разумный предел длины.
Примечание: вы можете попробовать сплайс (...), который имеет эту проблему, как Push (...) и Unshift (...).
Есть способ избежать этого максимального предела длины.
Кода -копия выглядит следующим образом:
функция CombineInto (a, b) {
var len = a.length;
for (var i = 0; i <len; i = i+5000) {
b.unshift.apply (b, a.slice (i, i+5000));
}
}
Подождите, наша читаемость пошла задом наперед. Вот и все, это может быть хуже и хуже, ха -ха.