В 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;
};
Вы можете сделать это следующим образом:
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;
// or
Array.from({ length: 5 }).fill('a')
Примечание. Дополнительные сведения о fill (...) и from (...) см. на предмет совместимости и поддержки браузера.
Array.from({length:5}, i => 1) // [1, 1, 1, 1, 1]
или создать массив с возрастающим значением
Array.from({length:5}, (e, i)=>i) // [0, 1, 2, 3, 4]
В lodash это не так уж плохо:
_.flatten(_.times(5, function () { return [2]; }));
// [2, 2, 2, 2, 2]
EDIT: еще лучше:
_.times(5, _.constant(2));
// [2, 2, 2, 2, 2]
EDIT: еще лучше:
_.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.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]
Я должен заметить, что расширение функциональности встроенных объектов может вызвать проблемы, если вы работаете с сторонними библиотеками. Всегда взвешивайте это в своих решениях.
Нет более простого способа. Вам нужно сделать цикл и вставить элементы в массив.
Если вам нужно повторить массив несколько раз:
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']
вдохновлен этим ответом
Другой однострочный:
Array.prototype.map.call([]+Array(5+1),function(){ return '2'; })
Используйте эту функцию:
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']
Эта функция создает массив (длина) элементов, где каждый элемент равен (значение), если (значение) является целым числом или строкой целого числа. Любые десятичные числа будут усечены. Если вы хотите десятичные числа, замените "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]
У меня были проблемы с указанными методами, когда я использую массив вроде
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;
};
Я обнаружил это сегодня, пытаясь сделать 2D-массив без использования циклов. Оглядываясь назад, объединение нового массива является опрятным; Я попытался сопоставить новый массив, который не работает, поскольку карта пропускает пустые слоты.
"#".repeat(5).split('').map(x => 0)
"#" char может быть любым допустимым одиночным символом. 5 будет переменной для количества элементов, которые вы хотите. Значение 7 будет значением, которое вы хотите заполнить своим массивом.
Новый метод заполнения лучше, и когда я закодировал это, я не знал, что он существует, и я не знаю, что повторение - это es6; Я собираюсь написать сообщение в блоге об использовании этого трюка в тандеме с уменьшением, чтобы сделать классные вещи.
http://jburger.us.to/2016/07/14/functionally-create-a-2d-array/
var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);В ответе Node.js:
> Array.from({length:5}).map(x => 2)
[ 2, 2, 2, 2, 2 ]
Если вы используете ленту utlity, например lodash/underscore, вы можете сделать это следующим образом:)
let result = _.map(_.times(foo), function() {return bar})
Может использоваться как однострочный:
function repeat(arr, len) {
while (arr.length < len) arr = arr.concat(arr.slice(0, len-arr.length));
return arr;
}
Улучшение Vivek answer, это работает для строк любой длины, чтобы заполнить массив длины n: Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)
Попробуй это:
"avinash ".repeat(5).trim().split(" ");
Мне нужен был способ повторить/зациклить массив (с n элементов) m раз.
Например, распространение списка (лиц) на неделю/месяц. Допустим, у меня есть 3 имени, и я хочу их повторить через неделю:
fillArray(["Adam", "Blair", "Curtis"], 7); // returns ["Adam", "Blair", "Curtis", "Adam", "Blair", "Curtis", "Adam"]
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"]