У меня есть JavaScript массив dataArray
, который я хочу затолкать в новый массив newArray
. Только я не хочу, чтобы newArray[0]
был dataArray
. Я хочу затолкать все элементы в новый массив:
var newArray = [];
newArray.pushValues(dataArray1);
newArray.pushValues(dataArray2);
// ...
или даже лучше:
var newArray = new Array (
dataArray1.values(),
dataArray2.values(),
// ... where values() (or something equivalent) would push the individual values into the array, rather than the array itself
);
Таким образом, теперь новый массив содержит все значения отдельных массивов данных. Можно ли использовать какую-нибудь комбинацию клавиш типа pushValues
, чтобы не перебирать каждый отдельный dataArray
, добавляя элементы один за другим?
Используйте функцию concat, например, так:
var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayA.concat(arrayB);
Значение newArray
будет [1, 2, 3, 4]
(массивА
и массивВ
останутся неизменными; concat
создает и возвращает новый массив для результата).
Если ваши массивы не огромны (см. оговорку ниже), вы можете использовать метод push()
массива, в который вы хотите добавить значения. push()
может принимать несколько параметров, поэтому вы можете использовать его метод apply()
для передачи массива значений в виде списка параметров функции. Преимущество метода concat()
в том, что он добавляет элементы в массив на месте, а не создает новый массив.
Однако, похоже, что для больших массивов (порядка 100 000 членов и более) этот трюк может не сработать. Для таких массивов лучше использовать цикл. Подробности см. на сайте https://stackoverflow.com/a/17368101/96100.
var newArray = [];
newArray.push.apply(newArray, dataArray1);
newArray.push.apply(newArray, dataArray2);
Возможно, вы захотите обобщить это до функции:
function pushArray(arr, arr2) {
arr.push.apply(arr, arr2);
}
... или добавить ее в прототип Array
'а:
Array.prototype.pushArray = function(arr) {
this.push.apply(this, arr);
};
var newArray = [];
newArray.pushArray(dataArray1);
newArray.pushArray(dataArray2);
... или эмулировать оригинальный метод push()
, разрешив несколько параметров, используя тот факт, что concat()
, как и push()
, допускает несколько параметров:
Array.prototype.pushArray = function() {
this.push.apply(this, this.concat.apply([], arguments));
};
var newArray = [];
newArray.pushArray(dataArray1, dataArray2);
Вот'версия последнего примера, основанная на цикле, подходящая для больших массивов и всех основных браузеров, включая IE<= 8:
Array.prototype.pushArray = function() {
var toPush = this.concat.apply([], arguments);
for (var i = 0, len = toPush.length; i < len; ++i) {
this.push(toPush[i]);
}
};
Я добавлю еще один "на будущее" и ответить
В ECMAScript 6, Вы можете использовать распространение синтаксис:
в
let arr1 = [0, 1, 2];
let arr2 = [3, 4, 5];
arr1.push(...arr2);
console.log(arr1)
в
Распространение синтаксис еще не включены во всех основных браузерах. На текущий совместимости см. В этом (постоянно обновляется) таблица совместимости.
Однако, вы можете использовать синтаксис распространение с Babel.js.
редактировать:
Смотрите Джек Гиффин's ответ ниже дополнительные замечания по их работе. Похоже, функция concat все-таки лучше и быстрее, чем выкладывать оператора.
Нашли элегантный способ из МДН
var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];
// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);
console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']
Или вы можете использовать опцию распространения оператора из ES6:
let fruits = [ 'apple', 'banana'];
const moreFruits = [ 'orange', 'plum' ];
fruits.push(...moreFruits); // ["apple", "banana", "orange", "plum"]
var a=new Array('a','b','c');
var b=new Array('d','e','f');
var d=new Array('x','y','z');
var c=a.concat(b,d)
Это решило вашу проблему?
Следующие кажется простым для меня:
var newArray = dataArray1.slice();
newArray.push.apply(newArray, dataArray2);
Как "подтолкнуть", которая принимает переменное количество аргументов, вы можете использовать метод применить
на толчок
функция, чтобы подтолкнуть все элементы в другой массив. Он создает
вызов толкать через свой первый аргумент (на"newArray" Ну вот) как "это" и
элементы массива, а остальные аргументы.
Этот "срез" в первый раз получил копию первого массива, так что вы Дон'т изменить его.
Обновление если вы используете версию JavaScript с ломтиком доступна, вы можете упростить вывести выражение для:
newArray.push(...dataArray2)
Функция, приведенная ниже, Не'т имеют проблему с длиной массива и выполняет лучше, чем все предложенные решения:
function pushArray(list, other) {
var len = other.length;
var start = list.length;
list.length = start + len;
for (var i = 0; i < len; i++ , start++) {
list[start] = other[i];
}
}
к сожалению, jspref отказывается принимать мои доводы, так вот они результаты, используя benchmark.js
Name | ops/sec | ± % | runs sampled
for loop and push | 177506 | 0.92 | 63
Push Apply | 234280 | 0.77 | 66
spread operator | 259725 | 0.40 | 67
set length and for loop | 284223 | 0.41 | 66
где
для петли и нажим:
for (var i = 0, l = source.length; i < l; i++) {
target.push(source[i]);
}
Нажимаем Применить:
target.push.apply(target, source);
распространение оператор:
target.push(...source);
и, наконец, 'установить длину и для петли' - Это выше функции
Есть несколько ответов про массив.прототип.толчок.применить. Вот наглядный пример:
в
в ВАР dataArray1 = [1, 2]; ВАР dataArray2 = [3, 4, 5]; значения var newArray = [ ]; Массив.прототип.толчок.применить(newArray, dataArray1); // newArray = [1, 2] Массив.прототип.толчок.применить(newArray, dataArray2); // newArray = [1, 2, 3, 4, 5] консоль.журнала(в формате JSON.преобразовать в строки(newArray)); // выводит: [1, 2, 3, 4, 5]
в
Если у вас есть синтаксис ES6 в:
в
var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
newArray.push(...dataArray1); // newArray = [1, 2]
newArray.push(...dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]
в
С помощью JavaScript ES6 в, вы можете использовать ... в качестве оператора, которое существенно преобразовать массив в значениями. Затем, вы можете сделать что-то вроде этого:
const myArray = [1,2,3,4,5];
const moreData = [6,7,8,9,10];
const newArray = [
...myArray,
...moreData,
];
В то время как синтаксис лаконичен, Я не знаю, как это работает изнутри и какие последствия для производительности на больших массивах.
Здесь'ы ES6 в сторону
в
var newArray = [];
let dataArray1 = [1,2,3,4]
let dataArray2 = [5,6,7,8]
newArray = [...dataArray1, ...dataArray2]
console.log(newArray)
в
выше способ подходит для большинства случаев и случаев это не так, пожалуйста, рассмотреть
функция concat
, как у вас есть сто тысяч элементов в массивах.
в
let dataArray1 = [1,2,3,4]
let dataArray2 = [5,6,7,8]
let newArray = dataArray1.concat(dataArray2);
console.log(newArray)
в
Для фактов, тест производительности на см. Этот тест jsperf и просмотрев некоторые вещи в консоли выполняются. Для исследования, в <а href="и https://www.irt.org/xref/core_objects.htm">сайте ИРТ.орг</а> используется. Ниже находится сборник всех этих источников вместе плюс пример функции внизу. в <предварительно>╔═══════════════╦══════╦═════════════════╦═══════════════╦═════════╦══════════╗ ║ Способ ║функция concat║нарезать&амп;толчок.применить ║ толчок.применять Х2 ║ дляпеременная элемента ║распространение ║ ╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ ║ швабры/сек ║179 ║104 ║ 76 ║ 81 ║28 ║ ╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ ║ Разреженные массивы ║да! ║Только нарезанный ║ нет ║ может в<SUP-серфинг и GT;2<суб> </суб></суп> ║нет ║ ║ держал разреженный массив ║ ║(1-й арг) ║ ║ ║ ║ ╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ Поддержка ║ ║несовременно 4║несовременно 5.5 ║ несовременно 5.5 ║ несовременно 4 ║края 12 ║ ║ (в<а href="и https://www.irt.org/xref/core_objects.htm">источник</а>) ║NNav 4║NNav 4.06 ║ NNav 4.06 ║ NNav 3 ║<удар>несовременно</удара> <удар>NNav</удара> ║ ╠═══════════════╬══════╬═════════════════╬═══════════════╬═════════╬══════════╣ ║Массива-как действует║нет ║только толкнул ║ да! ║ Да! ║Если у ║ ║как массив массив ║ ║ (2-й арг) ║ ║ ║ итератор<суп>1<суб> </суб></суп>║ ╚═══════════════╩══════╩═════════════════╩═══════════════╩═════════╩══════════╝ <суп>1</суп> если массив-как объект нет <и>символ.итератор</а> имущество, затем пытается распространяться он будет бросать исключение. <суп>2</SUP-серфинг> зависит от кода. В следующем примере кода "Да" и сохраняет разреженность.</пре>
function mergeCopyTogether(inputOne, inputTwo){
var oneLen = inputOne.length, twoLen = inputTwo.length;
var newArr = [], newLen = newArr.length = oneLen + twoLen;
for (var i=0, tmp=inputOne[0]; i !== oneLen; ++i) {
tmp = inputOne[i];
if (tmp !== undefined || inputOne.hasOwnProperty(i)) newArr[i] = tmp;
}
for (var two=0; i !== newLen; ++i, ++two) {
tmp = inputTwo[two];
if (tmp !== undefined || inputTwo.hasOwnProperty(two)) newArr[i] = tmp;
}
return newArr;
}
Как видно из вышеизложенного, я утверждаю, что функция concat-это почти всегда путь к производительности и возможность сохранения разреженности запасные массивов. Затем, для массива-любит (например, DOMNodeLists как документ.тела.дети`), я бы рекомендовал использовать цикл for, потому что он является 2-й наиболее эффективным и единственным методом, который сохраняет разреженные массивы. Ниже, мы быстро пройдемся по тому, что имеется в виду под разреженных массивов и массивов-любит, чтобы прояснить путаницу.
Во-первых, некоторые люди могут подумать, что это случайность и что производители браузеров в конечном итоге получить вокруг для оптимизации массива.прототип.толчок должен быть достаточно быстрым, чтобы победить время.прототип.функция concat. Неправильно! Массив.прототип.функция concat всегда будет быстрее (по крайней мере в принципе), потому что это просто копировать-вставлять данные. Ниже приведен упрощенный persuado-визуальную схему, что 32-битная реализация массива может выглядеть так (Обратите внимание, реальных реализаций много сложнее) в <предварительно>байт ║ данных ═════╬═══════════ 0х00 ║ инт nonNumericPropertiesLength = адресу 0x00000000 0х01 ║ там же 0x02 ║ там же 0x03 ║ там же 0х00 ║ int длина = слово 0x00000001 0х01 ║ там же 0x02 ║ там же 0x03 ║ там же 0х00 ║ инт valueIndex = адресу 0x00000000 0х01 ║ там же 0x02 ║ там же 0x03 ║ там же 0х00 ║ инт класса ValueType = JS_PRIMITIVE_NUMBER 0х01 ║ там же 0x02 ║ там же 0x03 ║ там же 0х00 ║ uintptr_t valuePointer = 0x38d9eb60 (или где он находится в памяти) 0х01 ║ там же 0x02 ║ там же 0x03 ║ там же</пред> Как видно из вышеизложенного, все, что вам нужно сделать, чтобы скопировать что-то подобное почти так же просто, как копирование побайтно. С Массива.прототип.толчок.применять, это намного больше, чем просто копировать-вставлять данные. В ".применить" есть, чтобы проверить каждый индекс в массив и преобразовать его в набор аргументов, прежде чем передать его в массив.прототип.толчок. Затем, Массив.прототип.пуш может дополнительно выделить больше памяти каждый раз, и (для некоторых реализаций браузера) может даже пересчитать некоторые позиции-поиск данных по разреженности. Альтернативный способ думать о нем это. Исходный массив одна большая стопка бумаг, скрепленных вместе. Исходный массив на два-это еще большие стопки бумаг. Это будет быстрее для вас
Когда некоторые члены массива просто отсутствуют. Например: в
// This is just as an example. In actual code,
// do not mix different types like this.
var mySparseArray = [];
mySparseArray[0] = "foo";
mySparseArray[10] = undefined;
mySparseArray[11] = {};
mySparseArray[12] = 10;
mySparseArray[17] = "bar";
console.log("Length: ", mySparseArray.length);
console.log("0 in it: ", 0 in mySparseArray);
console.log("arr[0]: ", mySparseArray[0]);
console.log("10 in it: ", 10 in mySparseArray);
console.log("arr[10] ", mySparseArray[10]);
console.log("20 in it: ", 20 in mySparseArray);
console.log("arr[20]: ", mySparseArray[20]);
в Кроме того, JavaScript позволяет легко инициализировать запасные массивов.
var mySparseArray = ["foo",,,,,,,,,,undefined,{},10,,,,,"bar"];
Массив-как объект, который имеет, по меньшей мере, свойство "length", но не был инициализирован с Новое Время
и []
; например, ниже предметы классифицируются как такие, как.
в <предварительно>{0: С "фу" и, 1: с "баре", длина:2}</пре>
в <предварительно>документ.тела.дети</пре>
в <предварительно>новый Uint8Array(3)</пре>
var slice = Array.prototype.slice;
// For arrays:
console.log(slice.call(["not an array-like, rather a real array"]));
// For array-likes:
console.log(slice.call({0: "foo", 1: "bar", length:2}));
console.log(slice.call(document.body.children));
console.log(slice.call(new Uint8Array(3)));
console.log(slice.call( function(){return arguments}() ));
в
var empty = [];
// For arrays:
console.log(empty.concat(["not an array-like, rather a real array"]));
// For array-likes:
console.log(empty.concat({0: "foo", 1: "bar", length:2}));
console.log(empty.concat(document.body.children));
console.log(empty.concat(new Uint8Array(3)));
console.log(empty.concat( function(){return arguments}() ));
в
У нас есть два массива A и B. код зачем здесь массив значение помещается в массив B.
let a = [2, 4, 6, 8, 9, 15]
function transform(a) {
let b = ['4', '16', '64']
a.forEach(function(e) {
b.push(e.toString());
});
return b;
}
transform(a)
[ '4', '16', '64', '2', '4', '6', '8', '9', '15' ]
Если вы хотите изменить исходный массив, вы можете распространять и давить:
``В JavaScript ВАР Источник = [1, 2, 3]; ВАР диапазон = [5, 6, 7]; длина ВАР = источник.толчок(...круг);
консоль.журнала(Источник); // [ 1, 2, 3, 5, 6, 7 ] консоль.журнал(длина); // 6 ``
Если вы хотите, чтобы убедиться, только элементы одного типа перейти в "источник" массива (не смешивая числа и строки например), то использовать TypeScript.
``Машинопись /**
вместо push() функция используется функция concat функция для IE. например,
var a=a.concat(a,new Array('amin'));
Это рабочий код и он отлично работает:
var els = document.getElementsByTagName('input'), i;
var invnum = new Array();
var k = els.length;
for(i = 0; i < k; i++){invnum.push(new Array(els[i].id,els[i].value))}