# Create an array with all numbers from min to max without a loop

I have two numbers, `min` and `max`, and I want to create an array that contains all number between them (including `min` and `max`).

The most obvious approach is to use a `for` loop for this, and `push` the single values onto an array. Nevertheless, this seems to be a quite naive approach, i.e. it’s imperative programming.

Now I was thinking of how to create such an array in a more functional style. Basically, something such as the reverse of a `reduce` function: Instead of reducing an array to a number, building up an array from two numbers.

How could I do this? What is a functional approach to solve this problem?

Basically, I’m thinking of something such as `10..20` in some other languages. What’s the most elegant equivalent for this in JavaScript?

## Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

### Solution 1

Inspired by this

``````var min = 3, max = 10;
var x = Array.apply(null, {length: max + 1}).map(Number.call, Number).slice(min);
console.log(x);
// [ 3, 4, 5, 6, 7, 8, 9, 10 ]
``````

The optimum version

``````var min = 3, max = 10;
var x = Array.apply(null, {length: max + 1 - min}).map(function(_, idx) {
return idx + min;
});
console.log(x);
// [ 3, 4, 5, 6, 7, 8, 9, 10 ]
``````

### Solution 2

You can think of a “functional” definition of range:

``````range(low, hi) = [], if low > hi
range(low, hi) = [low] (+) range(low+1,hi), otherwise,
``````

which leads to the JS definition:

``````function range(low,hi){
function rangeRec(low, hi, vals) {
if(low > hi) return vals;
vals.push(low);
return rangeRec(low+1,hi,vals);
}
return rangeRec(low,hi,[]);
}
``````

### Solution 3

A one line way. Inspired by How to create an array containing 1…N.

`Array.from({length: max-min+1}, (_, i) => i + min);`

Initiate an array from a computed length based on max and min. Then map each index value by a function which is "index + min". The reference is here.

Example:

``````const min = 12;
const max = 20;
const arr = Array.from({length: max-min+1}, (_, i) => i + min);
``````

### Solution 4

If you have harmony generators you can use this:

``````function* range(lorange,hirange){
var n = lorange;
while (n <= hirange){
yield n++;
}
}

rval= range(3,6);
``````

Now you can :

1. Use the for-of comprehension for iterators as substitute of array

``````for (i of rval)
console.log(i);

3
4
5
6
``````
2. Or you can use it to create an array like you want

``````rarray = [];
for (i of rval)
rarray.push(i);
``````

### Solution 5

Might be late to the party, but, based on this (es6)

``````const rangexy = (start, end) => Array.from({length: (end+1 - start)}, (v, k) => k + start);
``````

Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0