Tôi đang tìm kiếm bất kỳ giải pháp thay thế nào dưới đây để tạo một mảng JavaScript chứa từ 1 đến N trong đó N chỉ được biết khi chạy.

var foo = [];

for (var i = 1; i <= N; i++) {
   foo.push(i);
}

Đối với tôi cảm giác như có một cách để làm điều này mà không cần vòng lặp.

Nếu tôi có được những gì bạn đang theo đuổi, bạn muốn một dãy số 1..nmà sau này bạn có thể lặp lại.

Nếu đây là tất cả những gì bạn cần, bạn có thể làm điều này thay thế?

var foo = new Array(45); // create an empty array with length 45

sau đó khi bạn muốn sử dụng nó ... (chẳng hạn như không được tối ưu hóa)

for(var i = 0; i < foo.length; i++){
  document.write('Item: ' + (i + 1) + ' of ' + foo.length + '<br/>'); 
}

ví dụ: nếu bạn không cần lưu trữ bất cứ thứ gì trong mảng, bạn chỉ cần một thùng chứa có độ dài phù hợp mà bạn có thể lặp lại ... điều này có thể dễ dàng hơn.

Xem nó trong hành động ở đây: http://jsfiddle.net/3kcvm/

Trong ES6 sử dụng các phương thức Array from () và key () .

Array.from(Array(10).keys())
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Phiên bản ngắn hơn sử dụng toán tử trải .

[...Array(10).keys()]
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

var N = 10; 
Array.apply(null, {length: N}).map(Number.call, Number)

kết quả: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

hoặc với các giá trị ngẫu nhiên:

Array.apply(null, {length: N}).map(Function.call, Math.random)

kết quả: [0.7082694901619107, 0.9572225909214467, 0.8586748542729765, 0.8653848143294454, 0,00839877473190427, 0.9911756622605026, 0.8133423360995948, 0.8377588757575

Giải trình

Đầu tiên, lưu ý rằng Number.call(undefined, N)tương đương với Number(N), mà chỉ trả về N. Chúng ta sẽ sử dụng thực tế đó sau.

Array.apply(null, [undefined, undefined, undefined])tương đương với Array(undefined, undefined, undefined), nó tạo ra một mảng ba phần tử và gán undefinedcho từng phần tử.

Làm thế nào bạn có thể khái quát điều đó cho N yếu tố? Xem xét cách thức Array()hoạt động, đi như thế này:

function Array() {
    if ( arguments.length == 1 &&
         'number' === typeof arguments[0] &&
         arguments[0] >= 0 && arguments &&
         arguments[0] < 1 << 32 ) {
        return [ … ];  // array of length arguments[0], generated by native code
    }
    var a = [];
    for (var i = 0; i < arguments.length; i++) {
        a.push(arguments[i]);
    }
    return a;
}

Kể từ ECMAScript 5 , Function.prototype.apply(thisArg, argsArray)cũng chấp nhận một đối tượng giống như mảng gõ vịt làm tham số thứ hai của nó. Nếu chúng ta gọi Array.apply(null, { length: N }), nó sẽ thực thi

function Array() {
    var a = [];
    for (var i = 0; i < /* arguments.length = */ N; i++) {
        a.push(/* arguments[i] = */ undefined);
    }
    return a;
}

Bây giờ chúng ta có một mảng N -element, với mỗi phần tử được đặt thành undefined. Khi chúng ta gọi .map(callback, thisArg)nó, mỗi phần tử sẽ được đặt thành kết quả của callback.call(thisArg, element, index, array). Do đó, [undefined, undefined, …, undefined].map(Number.call, Number)sẽ ánh xạ từng phần tử tới (Number.call).call(Number, undefined, index, array), giống như Number.call(undefined, index, array), như chúng ta đã quan sát trước đó, đánh giá index. Điều đó hoàn thành mảng có các phần tử giống như chỉ mục của chúng.

Tại sao phải trải qua những rắc rối Array.apply(null, {length: N})thay vì chỉ Array(N)? Rốt cuộc, cả hai biểu thức sẽ dẫn đến một mảng N -element của các phần tử không xác định. Sự khác biệt là trong biểu thức trước, mỗi phần tử được đặt rõ ràng thành không xác định, trong khi ở phần sau, mỗi phần tử không bao giờ được đặt. Theo tài liệu của .map():

callbackchỉ được gọi cho các chỉ mục của mảng có các giá trị được gán; nó không được gọi cho các chỉ mục đã bị xóa hoặc chưa bao giờ được gán giá trị.

Do đó, Array(N)là không đủ; Array(N).map(Number.call, Number)sẽ cho kết quả trong một mảng chưa được khởi tạo có độ dài N .

Khả năng tương thích

Vì kỹ thuật này dựa trên hành vi Function.prototype.apply()được chỉ định trong ECMAScript 5, nên nó sẽ không hoạt động trong các trình duyệt tiền ECMAScript 5 như Chrome 14 và Internet Explorer 9.

Nhiều cách sử dụng ES6

Sử dụng toán tử lây lan ( ...) và phương thức khóa

[ ...Array(N).keys() ].map( i => i+1);

Điền / Bản đồ

Array(N).fill().map((_, i) => i+1);

Array.from

Array.from(Array(N), (_, i) => i+1)

Array.from và { length: N }hack

Array.from({ length: N }, (_, i) => i+1)

Lưu ý về hình thức tổng quát

Tất cả các hình thức trên mảng có thể sản xuất được khởi tạo với giá trị khá nhiều bất kỳ mong muốn bằng cách thay đổi i+1để biểu hiện yêu cầu (ví dụ như i*2, -i, 1+i*2, i%2và vv). Nếu biểu thức có thể được biểu thị bởi một số chức năng fthì biểu mẫu đầu tiên trở nên đơn giản

[ ...Array(N).keys() ].map(f)

Ví dụ:

Array.from({length: 5}, (v, k) => k+1); 
// [1,2,3,4,5]

Vì mảng được khởi tạo với undefinedtrên mỗi vị trí, giá trị của v sẽ làundefined

Ví dụ hiển thị tất cả các hình thức

let demo= (N) => {
  console.log(
    [ ...Array(N).keys() ].map(( i) => i+1),
    Array(N).fill().map((_, i) => i+1) ,
    Array.from(Array(N), (_, i) => i+1),
    Array.from({ length: N }, (_, i) => i+1)
  )
}

demo(5)

Ví dụ chung hơn với chức năng khởi tạo tùy chỉnh ftức là

[ ...Array(N).keys() ].map((i) => f(i))

hoặc thậm chí đơn giản hơn

[ ...Array(N).keys() ].map(f)

let demo= (N,f) => {
  console.log(
    [ ...Array(N).keys() ].map(f),
    Array(N).fill().map((_, i) => f(i)) ,
    Array.from(Array(N), (_, i) => f(i)),
    Array.from({ length: N }, (_, i) => f(i))
  )
}

demo(5, i=>2*i+1)

Mảng quản lý bẩm sinh chiều dài của họ. Khi chúng đi qua, các chỉ mục của chúng có thể được giữ trong bộ nhớ và được tham chiếu tại thời điểm đó. Nếu một chỉ số ngẫu nhiên cần được biết, indexOfphương pháp có thể được sử dụng.

Điều này cho biết, đối với nhu cầu của bạn, bạn có thể chỉ muốn khai báo một mảng có kích thước nhất định:

var foo = new Array(N);   // where N is a positive integer

/* this will create an array of size, N, primarily for memory allocation, 
   but does not create any defined values

   foo.length                                // size of Array
   foo[ Math.floor(foo.length/2) ] = 'value' // places value in the middle of the array
*/

ES6

Lây lan

Sử dụng toán tử trải rộng ( ...) và keysphương thức, cho phép bạn tạo một mảng tạm thời có kích thước N để tạo các chỉ mục và sau đó một mảng mới có thể được gán cho biến của bạn:

var foo = [ ...Array(N).keys() ];

Điền / Bản đồ

Trước tiên, bạn có thể tạo kích thước của mảng bạn cần, điền vào đó không xác định và sau đó tạo một mảng mới bằng cách sử dụng map, đặt từng phần tử cho chỉ mục.

var foo = Array(N).fill().map((v,i)=>i);

Array.from

Điều này sẽ được khởi tạo theo chiều dài của kích thước N và điền vào mảng trong một lần.

Array.from({ length: N }, (v, i) => i)

Thay cho các nhận xét và nhầm lẫn, nếu bạn thực sự muốn nắm bắt các giá trị từ 1..N trong các ví dụ trên, có một số tùy chọn:

1. nếu chỉ mục có sẵn, bạn chỉ cần tăng nó lên một (ví dụ ++i:).

2. trong trường hợp chỉ mục không được sử dụng - và có thể là cách hiệu quả hơn - là tạo mảng của bạn nhưng làm cho N đại diện cho N + 1, sau đó chuyển ra phía trước.

   Vì vậy, nếu bạn mong muốn 100 số:

   let arr; (arr=[ ...Array(101).keys() ]).shift()

Trong ES6 bạn có thể làm:

Array(N).fill().map((e,i)=>i+1);

http://jsbin.com/molabiluwa/edit?js,console

Chỉnh sửa: Thay đổi Array(45)để Array(N)kể từ khi bạn đã cập nhật các câu hỏi.

console.log(
  Array(45).fill(0).map((e,i)=>i+1)
);

Sử dụng phương thức Underscore _.range rất phổ biến

// _.range([start], stop, [step])

_.range(10); // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11); // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5); // => [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1); //  => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0); // => []

function range(start, end) {
    var foo = [];
    for (var i = start; i <= end; i++) {
        foo.push(i);
    }
    return foo;
}

Sau đó được gọi bởi

var foo = range(1, 5);

Không có cách tích hợp nào để thực hiện điều này trong Javascript, nhưng đó là một chức năng tiện ích hoàn toàn hợp lệ để tạo nếu bạn cần thực hiện nhiều lần.

Chỉnh sửa: Theo tôi, sau đây là một chức năng phạm vi tốt hơn. Có lẽ chỉ vì tôi thiên vị bởi LINQ, nhưng tôi nghĩ nó hữu ích hơn trong nhiều trường hợp. Số dặm của bạn có thể thay đổi.

function range(start, count) {
    if(arguments.length == 1) {
        count = start;
        start = 0;
    }

    var foo = [];
    for (var i = 0; i < count; i++) {
        foo.push(start + i);
    }
    return foo;
}

cách nhanh nhất để điền vào một Arrayv8 là:

[...Array(5)].map((_,i) => i);

kết quả sẽ là: [0, 1, 2, 3, 4]

Câu hỏi này có rất nhiều câu trả lời phức tạp, nhưng một câu hỏi đơn giản:

[...Array(255).keys()].map(x => x + 1)

Ngoài ra, mặc dù phần trên ngắn (và gọn gàng) để viết, tôi nghĩ phần sau nhanh hơn một chút (cho độ dài tối đa:

127, Int8,

255, Uint8,

32.767, Int16,

65,535, Uint16,

2.147.483.647, Int32,

4.294.967.295, Uint32.

(dựa trên các giá trị số nguyên tối đa ), cũng ở đây nhiều hơn về Mảng được nhập ):

(new Uint8Array(255)).map(($,i) => i + 1);

Mặc dù giải pháp này cũng không quá lý tưởng, bởi vì nó tạo ra hai mảng và sử dụng khai báo biến bổ sung "$" (không chắc chắn có cách nào để khắc phục điều đó bằng phương pháp này). Tôi nghĩ rằng giải pháp sau đây là cách nhanh nhất có thể để làm điều này:

for(var i = 0, arr = new Uint8Array(255); i < arr.length; i++) arr[i] = i + 1;

Bất cứ lúc nào sau khi tuyên bố này được thực hiện, bạn có thể đơn giản sử dụng biến "mảng" trong phạm vi hiện tại;

Nếu bạn muốn tạo một chức năng đơn giản từ nó (với một số xác minh cơ bản):

function range(min, max) {
    min = min && min.constructor == Number ? min : 0;
    !(max && max.constructor == Number && max > min) && // boolean statements can also be used with void return types, like a one-line if statement.
        ((max = min) & (min = 0));  //if there is a "max" argument specified, then first check if its a number and if its graeter than min: if so, stay the same; if not, then consider it as if there is no "max" in the first place, and "max" becomes "min" (and min becomes 0 by default)

    for(var i = 0, arr = new (
        max < 128 ? Int8Array : 
        max < 256 ? Uint8Array :
        max < 32768 ? Int16Array : 
        max < 65536 ? Uint16Array :
        max < 2147483648 ? Int32Array :
        max < 4294967296 ? Uint32Array : 
        Array
    )(max - min); i < arr.length; i++) arr[i] = i + min;
    return arr;
}



//and you can loop through it easily using array methods if you want
range(1,11).forEach(x => console.log(x));

//or if you're used to pythons `for...in` you can do a similar thing with `for...of` if you want the individual values:
for(i of range(2020,2025)) console.log(i);

//or if you really want to use `for..in`, you can, but then you will only be accessing the keys:

for(k in range(25,30)) console.log(k);

console.log(
    range(1,128).constructor.name,
    range(200).constructor.name,
    range(400,900).constructor.name,
    range(33333).constructor.name,
    range(823, 100000).constructor.name,
    range(10,4) // when the "min" argument is greater than the "max", then it just considers it as if there is no "max", and the new max becomes "min", and "min" becomes 0, as if "max" was never even written
);

vì vậy, với chức năng trên, "một lớp lót" siêu chậm ở trên trở thành siêu nhanh, thậm chí ngắn hơn:

range(1,14000);

Bạn có thể sử dụng điều này:

new Array(/*any number which you want*/)
    .join().split(',')
    .map(function(item, index){ return ++index;})

ví dụ

new Array(10)
    .join().split(',')
    .map(function(item, index){ return ++index;})

sẽ tạo mảng sau:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ES6 này sẽ thực hiện thủ thuật:

[...Array(12).keys()]

kiểm tra kết quả:

[...Array(12).keys()].map(number => console.log(number))

Nếu bạn tình cờ sử dụng d3.js trong ứng dụng của bạn như tôi, D3 cung cấp chức năng trợ giúp thực hiện điều này cho bạn.

Vì vậy, để có được một mảng từ 0 đến 4, thật dễ dàng như sau:

d3.range(5)
[0, 1, 2, 3, 4]

và để có được một mảng từ 1 đến 5, như bạn đã yêu cầu:

d3.range(1, 5+1)
[1, 2, 3, 4, 5]

Kiểm tra hướng dẫn này để biết thêm.

Sử dụng toán tử trải ES2015 / ES6

[...Array(10)].map((_, i) => i + 1)

console.log([...Array(10)].map((_, i) => i + 1))

Đây có lẽ là cách nhanh nhất để tạo ra một dãy số

Ngắn nhất

var a=[],b=N;while(b--)a[b]=b+1;

Nội tuyến

var arr=(function(a,b){while(a--)b[a]=a;return b})(10,[]);
//arr=[0,1,2,3,4,5,6,7,8,9]

Nếu bạn muốn bắt đầu từ 1

var arr=(function(a,b){while(a--)b[a]=a+1;return b})(10,[]);
//arr=[1,2,3,4,5,6,7,8,9,10]

Bạn muốn một chức năng?

function range(a,b,c){c=[];while(a--)c[a]=a+b;return c}; //length,start,placeholder
var arr=range(10,5);
//arr=[5,6,7,8,9,10,11,12,13,14]

TẠI SAO?

1. while là vòng lặp nhanh nhất

2. Cài đặt trực tiếp nhanh hơn push

3. [] nhanh hơn new Array(10)

4. nó ngắn ... nhìn mã đầu tiên. sau đó nhìn vào tất cả các chức năng khác ở đây.

Nếu bạn thích có thể không trực tiếp mà không cho

for(var a=[],b=7;b>0;a[--b]=b+1); //a=[1,2,3,4,5,6,7]

hoặc là

for(var a=[],b=7;b--;a[b]=b+1); //a=[1,2,3,4,5,6,7]

cách mới để điền Arraylà:

const array = [...Array(5).keys()]
console.log(array)

kết quả sẽ là: [0, 1, 2, 3, 4]

Nếu bạn đang sử dụng lodash, bạn có thể sử dụng _.range :

_.range([start=0], end, [step=1])

Tạo một mảng các số (dương và / hoặc âm) tiến triển từ đầu đến, nhưng không bao gồm, kết thúc. Bước -1 được sử dụng nếu bắt đầu phủ định được chỉ định mà không có kết thúc hoặc bước. Nếu kết thúc không được chỉ định, nó được đặt thành bắt đầu bằng bắt đầu rồi đặt thành 0.

Ví dụ:

_.range(4);
// ➜ [0, 1, 2, 3]

_.range(-4);
// ➜ [0, -1, -2, -3]

_.range(1, 5);
// ➜ [1, 2, 3, 4]

_.range(0, 20, 5);
// ➜ [0, 5, 10, 15]

_.range(0, -4, -1);
// ➜ [0, -1, -2, -3]

_.range(1, 4, 0);
// ➜ [1, 1, 1]

_.range(0);
// ➜ []

với ES6 bạn có thể làm:

// `n` is the size you want to initialize your array
// `null` is what the array will be filled with (can be any other value)
Array(n).fill(null)

Báo cáo tóm tắt cuối cùng .. Drrruummm Rolll -

Đây là mã ngắn nhất để tạo Mảng có kích thước N (ở đây là 10) mà không cần sử dụng ES6 . Phiên bản của Cocco ở trên gần nhưng không phải là ngắn nhất.

(function(n){for(a=[];n--;a[n]=n+1);return a})(10)

Nhưng người chiến thắng không thể tranh cãi của môn golf Code này (cạnh tranh để giải quyết một vấn đề cụ thể trong vài byte mã nguồn) là Niko Ruotsalainen . Sử dụng Array Con constructor và toán tử trải ES6 . (Hầu hết cú pháp ES6 là typeScript hợp lệ, nhưng sau đây thì không. Vì vậy, hãy thận trọng khi sử dụng nó)

[...Array(10).keys()]

Có một cách khác trong ES6, sử dụng Array.from , có 2 đối số, đầu tiên là một mảngLike (trong trường hợp này là một đối tượng có thuộc lengthtính) và thứ hai là một hàm ánh xạ (trong trường hợp này chúng ta ánh xạ mục vào chỉ mục của nó)

Array.from({length:10}, (v,i) => i)

cái này ngắn hơn và có thể được sử dụng cho các chuỗi khác như tạo số chẵn

Array.from({length:10}, (v,i) => i*2)

Ngoài ra, điều này có hiệu suất tốt hơn so với hầu hết các cách khác vì nó chỉ lặp một lần qua mảng. Kiểm tra đoạn trích để xem một số so sánh

// open the dev console to see results

count = 100000

console.time("from object")
for (let i = 0; i<count; i++) {
  range = Array.from({length:10}, (v,i) => i )
}
console.timeEnd("from object")

console.time("from keys")
for (let i =0; i<count; i++) {
  range = Array.from(Array(10).keys())
}
console.timeEnd("from keys")

console.time("apply")
for (let i = 0; i<count; i++) {
  range = Array.apply(null, { length: 10 }).map(function(element, index) { return index; })
}
console.timeEnd("apply")

Sử dụng các phương thức Array và =>cú pháp hàm mới từ tiêu chuẩn ES6 (chỉ Firefox tại thời điểm viết).

Bằng cách lấp đầy các lỗ với undefined:

Array(N).fill().map((_, i) => i + 1);

Array.fromlần lượt "lỗ" vào undefinedđể Array.maplàm việc như mong đợi:

Array.from(Array(5)).map((_, i) => i + 1)

for(var i,a=[i=0];i<10;a[i++]=i);

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Trong ES6:

Array.from({length: 1000}, (_, i) => i);

ES5:

Array.apply(0, {length: 1000}).map(function(x,i){return i});

Chỉ là một phiên bản ES6 khác .

Bằng cách sử dụng Array.fromđối số tùy chọn thứ hai:

Array.from (mảngLike [, mapFn [, thisArg]])

Chúng ta có thể xây dựng mảng được đánh số từ các Array(10)vị trí trống :

Array.from(Array(10), (_, i) => i)

var arr = Array.from(Array(10), (_, i) => i);
document.write(arr);

Có vẻ như hương vị duy nhất hiện tại không có trong danh sách các câu trả lời khá đầy đủ này là một trong đó có một máy phát điện; để khắc phục rằng:

const gen = N => [...(function*(){let i=0;while(i<N)yield i++})()]

có thể được sử dụng như vậy:

gen(4) // [0,1,2,3]

Điều thú vị ở đây là bạn không cần phải tăng ... Để lấy cảm hứng từ câu trả lời @ igor-shubin đã đưa ra, bạn có thể tạo ra một loạt các randoms rất dễ dàng:

const gen = N => [...(function*(){let i=0;
  while(i++<N) yield Math.random()
})()]

Và thay vì một cái gì đó dài đắt tiền hoạt động như:

const slow = N => new Array(N).join().split(',').map((e,i)=>i*5)
// [0,5,10,15,...]

thay vào đó bạn có thể làm:

const fast = N => [...(function*(){let i=0;while(i++<N)yield i*5})()]

Bạn có thể sử dụng Array fill và ánh xạ từ Es6; giống như một vài người gợi ý trong câu trả lời mà họ đưa ra cho câu hỏi này. Dưới đây là một vài ví dụ:

Example-One: Array(10).fill(0).map((e,i)=>i+1)

Result-One: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Example-Two: Array(100/10).fill(0).map((e,i)=>(i*10)+10)

Result-Two:[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Tôi thích điều này bởi vì tôi thấy nó thẳng tiến và dễ dàng hơn.

Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

Nguồn: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from

Sử dụng ES6

const generateArray = n => [...Array(n)].map((_, index) => index + 1);

Object.keys(Array.apply(0, Array(3))).map(Number)

Trả về [0, 1, 2]. Rất giống với câu trả lời xuất sắc của Igor Shubin , nhưng với ít mánh khóe hơn (và dài hơn một ký tự).

Giải trình:

• Array(3) // [undefined × 3]Tạo một mảng có độ dài n = 3. Thật không may, mảng này gần như vô dụng với chúng tôi, vì vậy chúng tôi phải
• Array.apply(0,Array(3)) // [undefined, undefined, undefined]làm cho mảng lặp đi lặp lại. Lưu ý: null phổ biến hơn như đối số đầu tiên của ứng dụng nhưng ngắn hơn 0.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] sau đó lấy các khóa của mảng (hoạt động vì Mảng là mảng typeof là một đối tượng có chỉ mục cho các khóa.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] và ánh xạ qua các phím, chuyển đổi chuỗi thành số.