Does JavaScript have a method like "range()" to generate a range within the supplied bounds?

Question

In PHP, you can do...

range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")

That is, there is a function that lets you get a range of numbers or characters by passing the upper and lower bounds.

Is there anything built-in to JavaScript natively for this? If not, how would I implement it?

• Yi Jiang: Prototype.js has the $R function, but other than that I don't really think so.
• btk: This (related) question has some excellent answers: stackoverflow.com/questions/6299500/…
• csharpfolk: When lover bound is zero this oneliner: Array.apply(null, { length: 10 }).map(eval.call, Number)
• KyleMit: Possible duplicate of Create a JavaScript array containing 1...N
• Dave F: No, but you can define the function using: const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step)); (see 'Sequence generator (range)' from MSDN) NOTE: This function only works if all parameters are specified (ie. range(1,5,1) produces the array [1,2,3,4,5], but range(1,5) produces an empty array)

Answer 1

Numbers

[...Array(5).keys()];
 => [0, 1, 2, 3, 4]

Character iteration

String.fromCharCode(...[...Array('D'.charCodeAt(0) - 'A'.charCodeAt(0) + 1).keys()].map(i => i + 'A'.charCodeAt(0)));
 => "ABCD"

Iteration

for (const x of Array(5).keys()) {
 console.log(x, String.fromCharCode('A'.charCodeAt(0) + x));
}
 => 0,"A" 1,"B" 2,"C" 3,"D" 4,"E"

As functions

function range(size, startAt = 0) {
 return [...Array(size).keys()].map(i => i + startAt);
}
function characterRange(startChar, endChar) {
 return String.fromCharCode(...range(endChar.charCodeAt(0) -
 startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

As typed functions

function range(size:number, startAt:number = 0):ReadonlyArray<number> {
 return [...Array(size).keys()].map(i => i + startAt);
}
function characterRange(startChar:string, endChar:string):ReadonlyArray<string> {
 return String.fromCharCode(...range(endChar.charCodeAt(0) -
 startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

lodash.js _.range() function

_.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]
String.fromCharCode(..._.range('A'.charCodeAt(0), 'D'.charCodeAt(0) + 1));
 => "ABCD"

Old non es6 browsers without a library:

Array.apply(null, Array(5)).map(function (_, i) {return i;});
 => [0, 1, 2, 3, 4]

console.log([...Array(5).keys()]);

(ES6 credit to nils petersohn and other commenters)

• Lodewijk: Because if it's useful anywhere it is probably useful in JS. (JS can do functional programming type stuff, which can benefit from a range(0 statement. That and a thousand other reasons it might be useful in some semirare case)
• Lewis: Any idea why simply using (new Array(5)).map(function (value, index) { return index; }) wouldn't work? This returns [undefined × 5] for me in Chrome DevTools.
• alex: @Lewis Because an array defined with that has empty slots that won't be iterated over with map() or one of its friends.
• nils petersohn: Array(5).fill() is also mappable
• Rico Kahler: Array.from(Array(5).keys()) is an ES6 alternative that works in typescript without the downlevelIteration compiler flag if anyone was looking

Answer 2

For numbers you can use ES6 Array.from(), which works in everything these days except IE:

Shorter version:

Array.from({length: 20}, (x, i) => i);

Longer version:

Array.from(new Array(20), (x, i) => i);​​​​​​

which creates an array from 0 to 19 inclusive. This can be further shortened to one of these forms:

Array.from(Array(20).keys());
// or
[...Array(20).keys()];

Lower and upper bounds can be specified too, for example:

Array.from(new Array(20), (x, i) => i + *lowerBound*);

An article describing this in more detail: http://www.2ality.com/2014/05/es6-array-methods.html

• Stu Cox: Slightly more succinct than the Array.from() method, and faster than both: Array(20).fill().map((_, i) => i)
• Aditya Singh: @Delapouite @jib And this as well: Array.from({length: end - start}, (v, k) => k + start)
• Neurotransmitter: Nifty if you'd like to create array of empty subarrays too (var matrix = Array.from(new Array(3), () => []);).
• mikebridge: Some android devices (mainly Samsung) seem to be missing Array.from: Uncaught TypeError: Object function Array() { [native code] } has no method 'from'.
• Stu Cox: @icc97 Yes, linters may complain, although in JavaScript omitting a function argument defined to be the same as passing undefined, so fill() (with no argument) isn’t wrong per se. The fill value isn’t used in that solution, so if you like you could use fill(0) to save a few characters.

Answer 3

My new favorite form (ES2015)

Array(10).fill(1).map((x, y) => x + y)

And if you need a function with a step param:

const range = (start, stop, step = 1) =>
 Array(Math.ceil((stop - start) / step)).fill(start).map((x, y) => x + y * step)

Another possible implementation suggested by the MDN docs:

// Sequence generator function 
// (commonly referred to as "range", e.g. Clojure, PHP etc)
const range = (start, stop, step) => 
 Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step))

• Johan Dettmar: The argument you pass into Array(Math.ceil((stop - start) / step) + 1), needs the +1 at the end, to really mimic php's "inclusive" behaviour.
• Stephen DuMont: Try this: Array(10).fill(1).map((x, i) => i)
• ximo: I fixed @rodfersou's code so that stop means the end position: let range = (start, stop, step=1) => Array(stop - start + 1).fill(start).map((x, y) => x + y * step)
• Jacktose: FYI MDN recommends a range function like the second example here: const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));
• Asker: It is simply incredible that a language as high-level and popular as JS still lacks a straightforward range or [:] syntax in 2023. I can fathom no reason for it other than layers upon layers of bureaucratic red tape. Perhaps someone should pressure the ES committee to add such a feature? Some nice new languages, such as Rust, have no problem adding syntactic sugar when it would help, even despite those languages being much more systematic and "closer to the bare metal" than JS.

Answer 4

Here's my 2 cents:

function range(start, end) {
 return Array.apply(0, Array(end - 1))
 .map((element, index) => index + start);
}

• James Robey: This is actually wrong because the question is asking for start & end values. Not start & count/distance.
• ElectRocnic: This answer does not work as expected. The output is not usable.
• qba-dev: it would work as expected, when Array(end - 1) is changed like Array(end - start + 1)

Answer 5

It works for characters and numbers, going forwards or backwards with an optional step.

var range = function(start, end, step) {
 var range = [];
 var typeofStart = typeof start;
 var typeofEnd = typeof end;
 if (step === 0) {
 throw TypeError("Step cannot be zero.");
 }
 if (typeofStart == "undefined" || typeofEnd == "undefined") {
 throw TypeError("Must pass start and end arguments.");
 } else if (typeofStart != typeofEnd) {
 throw TypeError("Start and end arguments must be of same type.");
 }
 typeof step == "undefined" && (step = 1);
 if (end < start) {
 step = -step;
 }
 if (typeofStart == "number") {
 while (step > 0 ? end >= start : end <= start) {
 range.push(start);
 start += step;
 }
 } else if (typeofStart == "string") {
 if (start.length != 1 || end.length != 1) {
 throw TypeError("Only strings with one character are supported.");
 }
 start = start.charCodeAt(0);
 end = end.charCodeAt(0);
 while (step > 0 ? end >= start : end <= start) {
 range.push(String.fromCharCode(start));
 start += step;
 }
 } else {
 throw TypeError("Only string and number types are supported");
 }
 return range;
}

jsFiddle.

If augmenting native types is your thing, then assign it to Array.range.

var range = function(start, end, step) {
 var range = [];
 var typeofStart = typeof start;
 var typeofEnd = typeof end;
 if (step === 0) {
 throw TypeError("Step cannot be zero.");
 }
 if (typeofStart == "undefined" || typeofEnd == "undefined") {
 throw TypeError("Must pass start and end arguments.");
 } else if (typeofStart != typeofEnd) {
 throw TypeError("Start and end arguments must be of same type.");
 }
 typeof step == "undefined" && (step = 1);
 if (end < start) {
 step = -step;
 }
 if (typeofStart == "number") {
 while (step > 0 ? end >= start : end <= start) {
 range.push(start);
 start += step;
 }
 } else if (typeofStart == "string") {
 if (start.length != 1 || end.length != 1) {
 throw TypeError("Only strings with one character are supported.");
 }
 start = start.charCodeAt(0);
 end = end.charCodeAt(0);
 while (step > 0 ? end >= start : end <= start) {
 range.push(String.fromCharCode(start));
 start += step;
 }
 } else {
 throw TypeError("Only string and number types are supported");
 }
 return range;
}
console.log(range("A", "Z", 1));
console.log(range("Z", "A", 1));
console.log(range("A", "Z", 3));
console.log(range(0, 25, 1));
console.log(range(0, 25, 5));
console.log(range(20, 5, 5));

Answer 6

Simple range function:

function range(start, stop, step) {
 var a = [start], b = start;
 while (b < stop) {
 a.push(b += step || 1);
 }
 return a;
}

---

To incorporate the BigInt data type some check can be included, ensuring that all variables are same typeof start:

function range(start, stop, step) {
 var a = [start], b = start;
 if (typeof start == 'bigint') {
 stop = BigInt(stop)
 step = step? BigInt(step): 1n;
 } else
 step = step || 1;
 while (b < stop) {
 a.push(b += step);
 }
 return a;
}

---

To remove values higher than defined by stop e.g. range(0,5,2) will include 6, which shouldn't be.

function range(start, stop, step) {
 var a = [start], b = start;
 while (b < stop) {
 a.push(b += step || 1);
 }
 return (b > stop) ? a.slice(0,-1) : a;
}

• daveharris: This doesn't work when step != 1, the while condition needs to take step into account. My updated version with a default step value: function range(start, stop, step){ step = step || 1 var a=[start], b=start; while((b+step) < stop){ console.log("b: " + b + ". a: " + a + "."); b+=step; a.push(b); } return a; }
• Mr. Polywhirl: @daveharris I added a default step above, (step || 1).
• windmaomao: i have to say just by looking at it, if you try million records, it'll crash your computer. If not, just try with one more zero. I don't think you can exceed a number with more than 8 zeros.

Answer 7

OK, in JavaScript we don't have a range() function like PHP, so we need to create the function which is quite easy thing, I write couple of one-line functions for you and separate them for Numbers and Alphabets as below:

for Numbers:

function numberRange (start, end) {
 return new Array(end - start).fill().map((d, i) => i + start);
}

and call it like:

numberRange(5, 10); //[5, 6, 7, 8, 9]

for Alphabets:

function alphabetRange (start, end) {
 return new Array(end.charCodeAt(0) - start.charCodeAt(0)).fill().map((d, i) => String.fromCharCode(i + start.charCodeAt(0)));
}

and call it like:

alphabetRange('c', 'h'); //["c", "d", "e", "f", "g"]

• Paul: I think there are off-by-one errors in these functions. Should be Array(end - start + 1), and Array(end.charCodeAt(0) - start.charCodeAt(0) + 1).

Answer 8

Array.range = function(a, b, step){
 var A = [];
 if(typeof a == 'number'){
 A[0] = a;
 step = step || 1;
 while(a+step <= b){
 A[A.length]= a+= step;
 }
 }
 else {
 var s = 'abcdefghijklmnopqrstuvwxyz';
 if(a === a.toUpperCase()){
 b = b.toUpperCase();
 s = s.toUpperCase();
 }
 s = s.substring(s.indexOf(a), s.indexOf(b)+ 1);
 A = s.split(''); 
 }
 return A;
}
 
 
Array.range(0,10);
// [0,1,2,3,4,5,6,7,8,9,10]
 
Array.range(-100,100,20);
// [-100,-80,-60,-40,-20,0,20,40,60,80,100]
 
Array.range('A','F');
// ['A','B','C','D','E','F')
 
Array.range('m','r');
// ['m','n','o','p','q','r']

• moltarze: You really shouldn't jerry-rig methods onto the Array prototype.
• Victor Cordeiro Costa: This method only works with integers and characters. If the parameters are null, undefined, NaN, boolean, array, object, etc, this method returns the following error: undefined method toUpperCase to etc!
• row: As miike3459 wrote, if one day Array.range is added to standard lib you might have a serious problem.

Answer 9

https://stackoverflow.com/a/49577331/8784402

With Delta/Step

smallest and one-liner

[...Array(N)].map((_, i) => from + i * step);

Examples and other alternatives

[...Array(10)].map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
Array.from(Array(10)).map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
Array.from(Array(10).keys()).map(i => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
[...Array(10).keys()].map(i => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]
Array(10).fill(0).map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
Array(10).fill().map((_, i) => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

Range Function

const range = (from, to, step) =>
 [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);
range(0, 9, 2);
//=> [0, 2, 4, 6, 8]
// can also assign range function as static method in Array class (but not recommended )
Array.range = (from, to, step) =>
 [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);
Array.range(2, 10, 2);
//=> [2, 4, 6, 8, 10]
Array.range(0, 10, 1);
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Array.range(2, 10, -1);
//=> []
Array.range(3, 0, -1);
//=> [3, 2, 1, 0]

As Iterators

class Range {
 constructor(total = 0, step = 1, from = 0) {
 this[Symbol.iterator] = function* () {
 for (let i = 0; i < total; yield from + i++ * step) {}
 };
 }
}
[...new Range(5)]; // Five Elements
//=> [0, 1, 2, 3, 4]
[...new Range(5, 2)]; // Five Elements With Step 2
//=> [0, 2, 4, 6, 8]
[...new Range(5, -2, 10)]; // Five Elements With Step -2 From 10
//=>[10, 8, 6, 4, 2]
[...new Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]
// Also works with for..of loop
for (i of new Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

As Generators Only

const Range = function* (total = 0, step = 1, from = 0) {
 for (let i = 0; i < total; yield from + i++ * step) {}
};
Array.from(Range(5, -2, -10));
//=> [-10, -12, -14, -16, -18]
[...Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]
// Also works with for..of loop
for (i of Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2
// Lazy loaded way
const number0toInf = Range(Infinity);
number0toInf.next().value;
//=> 0
number0toInf.next().value;
//=> 1
// ...

From-To with steps/delta

using iterators

class Range2 {
 constructor(to = 0, step = 1, from = 0) {
 this[Symbol.iterator] = function* () {
 let i = 0,
 length = Math.floor((to - from) / step) + 1;
 while (i < length) yield from + i++ * step;
 };
 }
}
[...new Range2(5)]; // First 5 Whole Numbers
//=> [0, 1, 2, 3, 4, 5]
[...new Range2(5, 2)]; // From 0 to 5 with step 2
//=> [0, 2, 4]
[...new Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

using Generators

const Range2 = function* (to = 0, step = 1, from = 0) {
 let i = 0,
 length = Math.floor((to - from) / step) + 1;
 while (i < length) yield from + i++ * step;
};
[...Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]
let even4to10 = Range2(10, 2, 4);
even4to10.next().value;
//=> 4
even4to10.next().value;
//=> 6
even4to10.next().value;
//=> 8
even4to10.next().value;
//=> 10
even4to10.next().value;
//=> undefined

For Typescript

class _Array<T> extends Array<T> {
 static range(from: number, to: number, step: number): number[] {
 return Array.from(Array(Math.floor((to - from) / step) + 1)).map(
 (v, k) => from + k * step
 );
 }
}
_Array.range(0, 9, 1);

https://stackoverflow.com/a/64599169/8784402

Generate Character List with one-liner

const charList = (a,z,d=1)=>(a=a.charCodeAt(),z=z.charCodeAt(),[...Array(Math.floor((z-a)/d)+1)].map((_,i)=>String.fromCharCode(a+i*d)));
console.log("from A to G", charList('A', 'G'));
console.log("from A to Z with step/delta of 2", charList('A', 'Z', 2));
console.log("reverse order from Z to P", charList('Z', 'P', -1));
console.log("from 0 to 5", charList('0', '5', 1));
console.log("from 9 to 5", charList('9', '5', -1));
console.log("from 0 to 8 with step 2", charList('0', '8', 2));
console.log("from α to ω", charList('α', 'ω'));
console.log("Hindi characters from क to ह", charList('क', 'ह'));
console.log("Russian characters from А to Я", charList('А', 'Я'));

For TypeScript

const charList = (p: string, q: string, d = 1) => {
 const a = p.charCodeAt(0),
 z = q.charCodeAt(0);
 return [...Array(Math.floor((z - a) / d) + 1)].map((_, i) =>
 String.fromCharCode(a + i * d)
 );
};

• Asker: As an aside, it is incredible that a language as high-level and popular as JS still lacks a straightforward range or [:] syntax in 2023. I can fathom no reason for it other than layers upon layers of bureaucratic red tape. Someone should pressure the ES committee to add such a feature. Newer languages, such as Rust, have no problem adding syntactic sugar when it would help, even though those languages are much more systematic and "close to the bare metal" than JS.

Answer 10

If, on Visual Studio Code, you faced the error:

screenshot

Type 'IterableIterator' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators.

Instead of

[...Array(3).keys()]

you can rely on

Array.from(Array(3).keys())

More on downlevelIteration

• InSync: The information given (that [...Array(3).keys()] might cause a static analysis error in a particular IDE) is only tangentially related to the question. Not to mention, this answer only contains information that can also be found in the linked answer. As such, this is less of an attempt to answer the question and more of an attempt to promote the linked answer (which has the same author).

Answer 11

var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);

• Rafael Xavier: Very neat! Although, it's important to note it doesn't work on any IE or Opera.
• mwag: @RafaelXavier will work on IE with Array.fill() polyfill

Answer 12

Handy function to do the trick, run the code snippet below

function range(start, end, step, offset) {
 
 var len = (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1;
 var direction = start < end ? 1 : -1;
 var startingPoint = start - (direction * (offset || 0));
 var stepSize = direction * (step || 1);
 
 return Array(len).fill(0).map(function(_, index) {
 return startingPoint + (stepSize * index);
 });
 
}
console.log('range(1, 5)=> ' + range(1, 5));
console.log('range(5, 1)=> ' + range(5, 1));
console.log('range(5, 5)=> ' + range(5, 5));
console.log('range(-5, 5)=> ' + range(-5, 5));
console.log('range(-10, 5, 5)=> ' + range(-10, 5, 5));
console.log('range(1, 5, 1, 2)=> ' + range(1, 5, 1, 2));

here is how to use it

range (Start, End, Step=1, Offset=0);

• inclusive - forward range(5,10) // [5, 6, 7, 8, 9, 10]
• inclusive - backward range(10,5) // [10, 9, 8, 7, 6, 5]
• step - backward range(10,2,2) // [10, 8, 6, 4, 2]
• exclusive - forward range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• offset - expand range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• offset - shrink range(5,10,0,-2) // [7, 8]
• step - expand range(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]

hope you find it useful.

---

And here is how it works.

Basically I'm first calculating the length of the resulting array and create a zero filled array to that length, then fill it with the needed values

• (step || 1) => And others like this means use the value of step and if it was not provided use 1 instead
• We start by calculating the length of the result array using (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1) to put it simpler (difference* offset in both direction/step)
• After getting the length, then we create an empty array with initialized values using new Array(length).fill(0); check here
• Now we have an array [0,0,0,..] to the length we want. We map over it and return a new array with the values we need by using Array.map(function() {})
• var direction = start < end ? 1 : 0; Obviously if start is not smaller than the end we need to move backward. I mean going from 0 to 5 or vice versa
• On every iteration, startingPoint + stepSize * index will gives us the value we need

Answer 13

--- UPDATE (Thanks to @lokhmakov for simplification) ---

Another version using ES6 generators ( see great Paolo Moretti answer with ES6 generators ):

const RANGE = (x,y) => Array.from((function*(){
 while (x <= y) yield x++;
})());
console.log(RANGE(3,7)); // [ 3, 4, 5, 6, 7 ]

Or, if we only need iterable, then:

const RANGE_ITER = (x,y) => (function*(){
 while (x <= y) yield x++;
})();
for (let n of RANGE_ITER(3,7)){
 console.log(n);
}
// 3
// 4
// 5
// 6
// 7

--- ORGINAL code was: ---

const RANGE = (a,b) => Array.from((function*(x,y){
 while (x <= y) yield x++;
})(a,b));

and

const RANGE_ITER = (a,b) => (function*(x,y){
 while (x <= y) yield x++;
})(a,b);

Answer 14

Using Harmony spread operator and arrow functions:

var range = (start, end) => [...Array(end - start + 1)].map((_, i) => start + i);

Example:

range(10, 15);
[ 10, 11, 12, 13, 14, 15 ]

Answer 15

In case want to use the range only to repeat a process n times u could simply use this code

[...Array(10)].map((item, index) => ( 
 console.log("item:", index)
))

• Henry Floyd: This method only works if your range starts at 0.
• DINA TAKLIT: The goal of this option is clearly mentioned repeat the process n times not to stimulate python range method necessarily, this is helpful in react especially to quickly create n items inside a component.
• Henry Floyd: The asker specifically requested a function that could accept upper and lower bounds. This option does not accept a lower bound and therefore does not answer the question.

Answer 16

You can use lodash or Undescore.js range:

var range = require('lodash/range')
range(10)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

---

Alternatively, if you only need a consecutive range of integers you can do something like:

Array.apply(undefined, { length: 10 }).map(Number.call, Number)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

---

In ES6 range can be implemented with generators:

function* range(start=0, end=null, step=1) {
 if (end == null) {
 end = start;
 start = 0;
 }
 for (let i=start; i < end; i+=step) {
 yield i;
 }
}

This implementation saves memory when iterating large sequences, because it doesn't have to materialize all values into an array:

for (let i of range(1, oneZillion)) {
 console.log(i);
}

• joews: The ES6 part is now the correct answer to this question. I would recommend removing the other parts, which are covered by other answers.
• Anona112: generators are somewhat strange if used outside a loop though: x=range(1, 10);//{} x;//{}// looks like an empty map WTF!?! x.next().value;// OK 1 ;x[3] // undefined, only with real array
• Paolo Moretti: @Anona112 you can use Array.from to convert generators to array instances and inspect the output.

Answer 17

range(start,end,step): With ES6 Iterators

You only ask for an upper and lower bounds. Here we create one with a step too.

You can easily create range() generator function which can function as an iterator. This means you don't have to pre-generate the entire array.

function * range ( start, end, step = 1 ) {
 let state = start;
 while ( state < end ) {
 yield state;
 state += step;
 }
 return;
};

Now you may want to create something that pre-generates the array from the iterator and returns a list. This is useful for functions that accept an array. For this we can use Array.from()

const generate_array = (start,end,step) =>
 Array.from( range(start,end,step) );

Now you can generate a static array easily,

const array1 = generate_array(1,10,2);
const array1 = generate_array(1,7);

But when something desires an iterator (or gives you the option to use an iterator) you can easily create one too.

for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {
 console.log(i)
}

Special Notes

• If you use Ramda, they have their own R.range as does Lodash

Answer 18

Did some research on some various Range Functions. Checkout the jsperf comparison of the different ways to do these functions. Certainly not a perfect or exhaustive list, but should help :)

The Winner is...

function range(lowEnd,highEnd){
 var arr = [],
 c = highEnd - lowEnd + 1;
 while ( c-- ) {
 arr[c] = highEnd--
 }
 return arr;
}
range(0,31);

Technically its not the fastest on firefox, but crazy speed difference (imho) on chrome makes up for it.

Also interesting observation is how much faster chrome is with these array functions than firefox. Chrome is at least 4 or 5 times faster.

• binaryfunt: Note that this was compared against range functions that included a step size parameter

Answer 19

Not implemented yet!

Using the new Number.range proposal (stage 2):

[...Number.range(1, 10)]
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

• SparK: Fun fact: The proposal github page mentions this very question as one of the reasons to implement the feature into the language and provides a polyfill that should be useful for everyone wanting to keep their answers compatible with future implementation.

Answer 20

This may not be the best way. But if you are looking to get a range of numbers in a single line of code. For example 10 - 50

Array(40).fill(undefined).map((n, i) => i + 10)

Where 40 is (end - start) and 10 is the start. This should return [10, 11, ..., 50]

Answer 21

(from, to) => [...Array(to - from)].map((_,i)=> i + from)

Answer 22

An interesting challenge would be to write the shortest function to do this. Recursion to the rescue!

function r(a,b){return a>b?[]:[a].concat(r(++a,b))}

Tends to be slow on large ranges, but luckily quantum computers are just around the corner.

An added bonus is that it's obfuscatory. Because we all know how important it is to hide our code from prying eyes.

To truly and utterly obfuscate the function, do this:

function r(a,b){return (a<b?[a,b].concat(r(++a,--b)):a>b?[]:[a]).sort(function(a,b){return a-b})}

• nafg: Short != simple, but simpler is better. Here's an easier to read version: const range = (a, b) => (a>=b) ? [] : [a, ...range(a+1, b)], using ES6 syntax
• 7vujy0f0hy: @nafg: const range = (a, b, Δ = 1) => (a > b) ? [] : [a, ...range(a + Δ, b, Δ)];. Also upvoting the whole answer for the comment.

Answer 23

I would code something like this:

function range(start, end) {
 return Array(end-start).join(0).split(0).map(function(val, id) {return id+start});
} 
range(-4,2);
// [-4,-3,-2,-1,0,1]
range(3,9);
// [3,4,5,6,7,8]

It behaves similarly to Python range:

>>> range(-4,2)
[-4, -3, -2, -1, 0, 1]

Answer 24

My personal favorite:

const range = (start, end) => new Array(end-start+1).fill().map((el, ind) => ind + start);

• Simon Zyx: maybe better [...Array(end-start+1)].map((el, ind) => ind + start); ?

Answer 25

ES6

Use Array.from (docs here):

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

Answer 26

A rather minimalistic implementation that heavily employs ES6 can be created as follows, drawing particular attention to the Array.from() static method:

const getRange = (start, stop) => Array.from(
 new Array((stop - start) + 1),
 (_, i) => i + start
);

• dietary-wheevil: As a side note, I've created a Gist in which I made an "enhanced" getRange() function of sorts. In particular, I aimed to capture edge cases that might be unaddressed in the bare-bones variant above. Additionally, I added support for alphanumeric ranges. In other words, calling it with two supplied inputs like 'C' and 'K' (in that order) returns an array whose values are the sequential set of characters from the letter 'C' (inclusive) through the letter 'K' (exclusive): getRange('C', 'K'); // => ["C", "D", "E", "F", "G", "H", "I", "J"]
• Soldeplata Saketos: you don't need the new keyword

Answer 27

Though this is not from PHP, but an imitation of range from Python.

function range(start, end) {
 var total = [];
 if (!end) {
 end = start;
 start = 0;
 }
 for (var i = start; i < end; i += 1) {
 total.push(i);
 }
 return total;
}
console.log(range(10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
console.log(range(0, 10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(range(5, 10)); // [5, 6, 7, 8, 9] 

Answer 28

The standard Javascript doesn't have a built-in function to generate ranges. Several javascript frameworks add support for such features, or as others have pointed out you can always roll your own.

If you'd like to double-check, the definitive resource is the ECMA-262 Standard.

• Pithikos: Well this didn't help at all.
• Mike Dinescu: @Pithikos I see this question has been edited since it was originally asked and the OP wanted to know if there is a native range function in JS.

Answer 29

This one works also in reverse.

const range = ( a , b ) => Array.from( new Array( b > a ? b - a : a - b ), ( x, i ) => b > a ? i + a : a - i );
range( -3, 2 ); // [ -3, -2, -1, 0, 1 ]
range( 1, -4 ); // [ 1, 0, -1, -2, -3 ]

Answer 30

d3 also has a built-in range function.

See https://github.com/d3/d3-array#range:

d3.range([start, ]stop[, step])

Generates an array containing an arithmetic progression, similar to the Python built-in range. This method is often used to iterate over a sequence of numeric or integer values, such as the indexes into an array. Unlike the Python version, the arguments are not required to be integers, though the results are more predictable if they are due to floating point precision. If step is omitted, it defaults to 1.

Example:

d3.range(10)
// returns [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]