Создать массив с одним и тем же элементом, повторенным несколько раз
В Python, где [2] это список, следующий код дает этот вывод:
[2] * 5 # Outputs: [2,2,2,2,2]
Существует ли простой способ сделать это с помощью массива в JavaScript?
Я написал следующую функцию, но есть ли что-то короче или лучше?
var repeatelem = function(elem, n){
// returns an array with element elem repeated n times.
var arr = [];
for (var i = 0; i <= n; i++) {
arr = arr.concat(elem);
};
return arr;
};
26 ответов
Вы можете сделать это так:
function fillArray(value, len) {
if (len == 0) return [];
var a = [value];
while (a.length * 2 <= len) a = a.concat(a);
if (a.length < len) a = a.concat(a.slice(0, len - a.length));
return a;
}
Он удваивает массив в каждой итерации, поэтому он может создать действительно большой массив за несколько итераций.
Примечание: вы также можете значительно улучшить свою функцию, используя push вместо concat, как concat будет создавать новый массив каждую итерацию. Вот так (показано только в качестве примера того, как вы можете работать с массивами):
function fillArray(value, len) {
var arr = [];
for (var i = 0; i < len; i++) {
arr.push(value);
}
return arr;
}
В ES6 используется метод Array fill ()
Array(5).fill(2)
//=> [2, 2, 2, 2, 2]
>>> Array.apply(null, Array(10)).map(function(){return 5})
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
>>> //Or in ES6
>>> [...Array(10)].map((_, i) => 5)
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
Ты можешь попробовать:
Array(6).join('a').split(''); // returns ['a','a','a','a','a'] (5 times)
Обновление (01/06/2018):
Теперь вы можете повторять набор символов.
new Array(5).fill('a'); // give the same result as above;
Примечание: обращайтесь за поддержкой ( https://mzl.la/1tBUwu4).
... и на помощь приходит Array.fill()!
Раньше все это писал вручную, не зная этого 🤦🏽♂️
Если вам нужно повторить массив, используйте следующее.
Array.from({length: 3}).fill(['a','b','c']).flat()
вернусь
Array(9) [ "a", "b", "c", "a", "b", "c", "a", "b", "c" ]
Array.from({length:5}, i => 1) // [1, 1, 1, 1, 1]
или создать массив с возрастающим значением
Array.from({length:5}, (e, i)=>i) // [0, 1, 2, 3, 4]
В Лодаше все не так плохо
_.flatten(_.times(5, function () { return [2]; }));
// [2, 2, 2, 2, 2]
РЕДАКТИРОВАТЬ: даже лучше:
_.times(5, _.constant(2));
// [2, 2, 2, 2, 2]
РЕДАКТИРОВАТЬ: даже лучше:
_.fill(Array(5), 2);
[c] * n можно записать как:
Array(n+1).join(1).split('').map(function(){return c;})
Таким образом, для [2] * 5
Array(6).join(1).split('').map(function(){return 2;})
Вы также можете расширить функциональность Array следующим образом:
Array.prototype.fill = function(val){
for (var i = 0; i < this.length; i++){
this[i] = val;
}
return this;
};
// used like:
var arry = new Array(5).fill(2);
// or
var arry = new Array(5);
arry.fill(2);
console.log(arry); //[2, 2, 2, 2, 2]
Следует отметить, что расширение функциональности встроенных объектов может вызвать проблемы, если вы работаете со сторонними библиотеками. Всегда взвешивайте это в своих решениях.
В реплике Node.js:
> Array.from({length:5}).map(x => 2)
[ 2, 2, 2, 2, 2 ]
Нет более простого способа. Вам нужно сделать цикл и вставить элементы в массив.
Если вам нужно повторить массив несколько раз:
var arrayA = ['a','b','c'];
var repeats = 3;
var arrayB = Array.apply(null, {length: repeats * arrayA.length})
.map(function(e,i){return arrayA[i % arrayA.length]});
// result: arrayB = ['a','b','c','a','b','c','a','b','c']
вдохновленный этим ответом
Используйте эту функцию:
function repeatElement(element, count) {
return Array(count).fill(element)
}
>>> repeatElement('#', 5).join('')
"#####"
Или для более компактной версии:
const repeatElement = (element, count) =>
Array(count).fill(element)
>>> repeatElement('#', 5).join('')
"#####"
Или для версии с карри:
const repeatElement = element => count =>
Array(count).fill(element)
>>> repeatElement('#')(5).join('')
"#####"
Вы можете использовать эту функцию со списком:
const repeatElement = (element, count) =>
Array(count).fill(element)
>>> ['a', 'b', ...repeatElement('c', 5)]
['a', 'b', 'c', 'c', 'c', 'c', 'c']
Вы можете использовать SpreadOpeator и функцию map() для создания массива с одним и тем же элементом, повторяющимся несколько раз.
function fillArray(value,len){
return [...Array(len).keys()].map(x=> value);
}
Я обнаружил это сегодня, пытаясь создать двумерный массив без использования циклов. Оглядываясь назад, можно сказать, что присоединение к новому массиву очень удобно; Я попытался отобразить новый массив, который не работает, так как карта пропускает пустые слоты.
"#".repeat(5).split('').map(x => 0)
Символ "#" может быть любым допустимым одиночным символом. 5 будет переменной для количества элементов, которые вы хотите. 7 будет значением, которым вы хотите заполнить ваш массив.
Новый метод заполнения лучше, и когда я кодировал это, я не знал, что он существует, и я не знал, что повторитель es6; Я собираюсь написать сообщение в блоге об использовании этого трюка в тандеме с "уменьшить", чтобы делать классные вещи.
http://jburger.us.to/2016/07/14/functionally-create-a-2d-array/
Еще один вкладыш:
Array.prototype.map.call([]+Array(5+1),function(){ return '2'; })
У меня были проблемы с упомянутыми методами, когда я использую массив, как
var array = ['foo', 'bar', 'foobar'];
var filled = array.fill(7);
//filled should be ['foo', 'bar', 'foobar', 'foo', 'bar', 'foobar', 'foo']
Чтобы получить это я использую:
Array.prototype.fill = function(val){
var l = this.length;
if(l < val){
for(var i = val-1-l; i >= 0; i--){
this[i+l] = this[i % l];
}
}
return this;
};
Эта функция создает массив элементов (length), где каждый элемент равен (value), если (value) является целым числом или строкой целого числа. Любые десятичные числа будут усечены. Если вам нужны десятичные числа, замените "parseInt (" на "parseFloat (")
function fillArray(length, intValue) {
var vals = (new Array(length + 1)).join(intValue + '|').split('|').slice(0,length);
for(var i = 0; i < length; i += 1) {
vals[i] = parseInt(vals[i]);
}
return vals;
}
Примеры:
fillArray(5, 7) // returns [7,7,7,7,7]
fillArray(5, 7.5) // returns [7,7,7,7,7]
fillArray(5, 200) // returns [200,200,200,200,200]
Улучшение ответа Vivek, это работает для строк любой длины, чтобы заполнить массив длины n: Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)
var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);Это могут быть другие ответы.
let cards = ["A","2","3","4","5","6","7","8","9","10","J","Q" "," К "];
let totalCards = [... карты, ... карты, ... карты, ... карты];
Может использоваться как однострочник:
function repeat(arr, len) {
while (arr.length < len) arr = arr.concat(arr.slice(0, len-arr.length));
return arr;
}
Если вы используете пояс utlity, например, lodash/underscore, вы можете сделать это следующим образом:)
let result = _.map(_.times(foo), function() {return bar})
Мне нужен был способ повторить массив (с n элементов) m раз. Использовали следующую функцию:
function fillArray(pattern, count) {
let result = [];
if (["number", "string"].includes(typeof pattern)) {
result = new Array(5);
result.fill(pattern);
}
else if (pattern instanceof Array) {
for (let i = 0; i < count; i++) {
result = result.concat(pattern);
}
result = result.slice(0, count);
}
return result;
}
fillArray("a", 5); // ["a", "a", "a", "a", "a"]
fillArray(1, 5); // [1, 1, 1, 1, 1]
fillArray(["a", "b"], 5); // ["a", "b", "a", "b", "a"]