Tạo một mảng với cùng một phần tử được lặp lại nhiều lần

Trong Python, [2]danh sách ở đâu, đoạn mã sau cung cấp đầu ra này:

[2] * 5 # Outputs: [2,2,2,2,2]

Có tồn tại một cách dễ dàng để làm điều này với một mảng trong JavaScript không?

Tôi đã viết các chức năng sau đây để làm điều đó, nhưng có cái gì ngắn hơn hoặc tốt hơn?

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;
};

Bạn có thể làm như thế này:

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;
}

Nó nhân đôi mảng trong mỗi lần lặp, vì vậy nó có thể tạo ra một mảng thực sự lớn với vài lần lặp.

Lưu ý: Bạn cũng có thể cải thiện chức năng của mình rất nhiều bằng cách sử dụng pushthay vì concat, như concatsẽ tạo ra một mảng mới mỗi lần lặp. Giống như thế này (được hiển thị như một ví dụ về cách bạn có thể làm việc với mảng):

function fillArray(value, len) {
  var arr = [];
  for (var i = 0; i < len; i++) {
    arr.push(value);
  }
  return arr;
}

Trong ES6 sử dụng phương thức 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]

bạn co thể thử:

Array(6).join('a').split(''); // returns ['a','a','a','a','a'] (5 times)

Cập nhật (01/06/2018) :

Bây giờ bạn có thể có một bộ ký tự lặp lại.

new Array(5).fill('a'); // give the same result as above;
// or
Array.from({ length: 5 }).fill('a')

Lưu ý: Kiểm tra thêm về điền (...) và từ (...) để biết khả năng tương thích và hỗ trợ trình duyệt.

Cập nhật (05/11/2019) :

Một cách khác, không sử dụng fillhoặc from, hoạt động cho chuỗi có độ dài bất kỳ:

Array.apply(null, Array(3)).map(_ => 'abc') // ['abc', 'abc', 'abc']

Tương tự như câu trả lời trên . Thêm cho sự hoàn thiện.

Array.from({length:5}, i => 1) // [1, 1, 1, 1, 1]

hoặc tạo mảng với giá trị tăng dần

Array.from({length:5}, (e, i)=>i) // [0, 1, 2, 3, 4]

Trong lodash nó không quá tệ:

_.flatten(_.times(5, function () { return [2]; }));
// [2, 2, 2, 2, 2]

EDIT : Thậm chí tốt hơn:

_.times(5, _.constant(2));
// [2, 2, 2, 2, 2]

EDIT : Thậm chí tốt hơn:

_.fill(Array(5), 2);

[c] * n có thể được viết như:

Array(n+1).join(1).split('').map(function(){return c;})

vì vậy đối với [2] * 5

Array(6).join(1).split('').map(function(){return 2;})

Bạn cũng có thể mở rộng chức năng của Array như vậy:

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] 

Tôi nên lưu ý rằng việc mở rộng chức năng của các đối tượng tích hợp có thể gây ra sự cố nếu bạn đang làm việc với các thư viện của bên thứ 3. Luôn cân nhắc điều này vào quyết định của bạn.

Trong REPL của Node.js:

> Array.from({length:5}).map(x => 2)
[ 2, 2, 2, 2, 2 ]

Trong trường hợp bạn cần lặp lại một mảng nhiều lần:

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']

lấy cảm hứng từ câu trả lời này

Không có cách nào dễ dàng hơn. Bạn cần tạo một vòng lặp và đẩy các phần tử vào mảng.

Sử dụng chức năng này:

function repeatElement(element, count) {
    return Array(count).fill(element)
}

>>> repeatElement('#', 5).join('')
"#####"

Hoặc cho phiên bản nhỏ gọn hơn:

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> repeatElement('#', 5).join('')
"#####"

Hoặc cho phiên bản cà ri có thể:

const repeatElement = element => count =>
    Array(count).fill(element)

>>> repeatElement('#')(5).join('')
"#####"

Bạn có thể sử dụng chức năng này với một danh sách:

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> ['a', 'b', ...repeatElement('c', 5)]
['a', 'b', 'c', 'c', 'c', 'c', 'c']

Nếu bạn cần lặp lại một mảng, sử dụng như sau.

Array.from({ length: 3 }).fill(['a','b','c']).flat()

sẽ trở lại

Array(9) [ "a", "b", "c", "a", "b", "c", "a", "b", "c" ]

Một lớp lót khác:

Array.prototype.map.call([]+Array(5+1),function(){ return '2'; })

Hàm này tạo ra một mảng gồm các phần tử (độ dài) trong đó mỗi phần tử bằng (giá trị) miễn là (giá trị) là một số nguyên hoặc chuỗi của một số nguyên. Bất kỳ số thập phân sẽ được cắt ngắn. Nếu bạn muốn số thập phân, thay thế "parseInt ( " bằng " 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;
}

Ví dụ:

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]

Tôi gặp vấn đề với các phương thức được đề cập khi tôi sử dụng một mảng như

var array = ['foo', 'bar', 'foobar'];
var filled = array.fill(7);

//filled should be ['foo', 'bar', 'foobar', 'foo', 'bar', 'foobar', 'foo']

Để có được điều này tôi đang sử dụng:

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;
};

Tôi phát hiện ra điều này ngày hôm nay trong khi cố gắng tạo một mảng 2D mà không sử dụng các vòng lặp. Nhìn lại, tham gia một mảng mới là gọn gàng; Tôi đã thử ánh xạ một mảng mới, không hoạt động khi bản đồ bỏ qua các vị trí trống.

"#".repeat(5).split('').map(x => 0)

Char "#" có thể là bất kỳ ký tự đơn hợp lệ nào. 5 sẽ là một biến cho số lượng phần tử bạn muốn. 7 sẽ là giá trị bạn muốn điền vào mảng của bạn.

Phương thức điền mới tốt hơn và khi tôi mã hóa nó, tôi không biết nó tồn tại, tôi cũng không biết lặp lại là es6; Tôi sẽ viết một bài đăng trên blog về việc sử dụng thủ thuật này song song với việc giảm bớt để làm những điều tuyệt vời.

http://jburger.us.to/2016/07/14/feftally-create-a-2d-array/

Thử cái này:

"avinash ".repeat(5).trim().split(" ");

Nếu bạn đang sử dụng một vành đai tiện dụng như lodash / gạch dưới, bạn có thể làm như thế này :)

let result = _.map(_.times(foo), function() {return bar})

Có thể được sử dụng như một lớp lót quá:

function repeat(arr, len) {
    while (arr.length < len) arr = arr.concat(arr.slice(0, len-arr.length));
    return arr;
}

Cải thiện câu trả lời của Vivek , điều này hoạt động đối với các chuỗi có độ dài bất kỳ, để điền vào một mảng có độ dài n:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Tôi cần một cách để lặp lại / lặp một mảng (với n mục) m lần.

Ví dụ: phân phối danh sách (của người) đến một tuần / tháng. Giả sử tôi có 3 tên và tôi muốn chúng lặp lại sau một tuần:

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"]