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?
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;
}
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));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)
(new Array(5)).map(function (value, index) { return index; }) wouldn't work? This returns [undefined × 5] for me in Chrome DevTools. –
Reginareginald map() or one of its friends. –
Vanegas [...new Array(5)] , only working with modern browser or using transpiler (ES2015) –
Mismanage Array(5).fill() is also mappable –
Chibouk Array.from(Array(5).keys()) is an ES6 alternative that works in typescript without the downlevelIteration compiler flag if anyone was looking –
Koodoo low and high bounds: Array.apply(null, Array(bounds.high-bounds.low+1)).map(function (_, i) {return i+bounds.low;}); –
Louvar Array.from(Array(10), (_, i) => i + 1) //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] Source: https://mcmap.net/q/20939/-how-to-create-an-array-containing-1-n –
Knuckleduster [...Array(n).keys()].slice(startAt-1), .e. [...Array(7).keys()].slice(4) for [4,5,6,7] –
Briar Array(5).fill() is mappable, and preferable because is WAY more performant (~4x) than the spread of [...Array(5).keys()] –
Blackguard const range = (start, end, inc) => (function r (s, e = end, i = inc) { return s > e ? [] : [s, ...r(s + i)] })(start) and without const range = (start, end) => start > end ? [] : [start, ...range(start + 1, end)] increment –
Minefield range or [:] syntax in 2023. –
Tenne range or [:] syntax has been added to JS yet. 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? It seems long overdue. 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. –
Tenne 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
Array.from() method, and faster than both: Array(20).fill().map((_, i) => i) –
Nippon Array.from({length: end - start}, (v, k) => k + start) –
Reyna var matrix = Array.from(new Array(3), () => []);). –
Alisha Uncaught TypeError: Object function Array() { [native code] } has no method 'from'. –
Start 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. –
Nippon Array.from form could eventually be faster than spread etc. for the original use case on the top (while the spreading version of the answer here doesn't generate what the OP asked). The reason for why Array.from could be faster is that the spec doesn't require the materialization of an interim array with undefineds, as the callback function (2nd arg of Array.from) can directly run as the initial array is being written. Faster, and lower pressure on GC if browsers optimize this as the spec expressly hints at it –
Harte 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))
Array(Math.ceil((stop - start) / step) + 1), needs the +1 at the end, to really mimic php's "inclusive" behaviour. –
Recency let range = (start, stop, step=1) => Array(stop - start + 1).fill(start).map((x, y) => x + y * step) –
Traveler range function like the second example here: const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step)); –
Harmonious Here's my 2 cents:
function range(start, end) {
return Array.apply(0, Array(end - 1))
.map((element, index) => index + start);
}
Array(end - 1) is changed like Array(end - start + 1) –
Facility 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;
}
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));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;
}
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; } –
Uuge (step || 1). –
Amador 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"]
Array(end - start + 1), and Array(end.charCodeAt(0) - start.charCodeAt(0) + 1). –
Mattress 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']
Array prototype. –
Enrich undefined method toUpperCase to etc! –
Bowerman Array.range is added to standard lib you might have a serious problem. –
Sedimentation https://mcmap.net/q/20940/-how-to-generate-range-of-numbers-from-0-to-n-in-es2015-only
[...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]
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]
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
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
// ...
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]
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
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://mcmap.net/q/20941/-how-to-generate-an-array-of-the-alphabet
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('А', 'Я'));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)
);
};
var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);
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);
range(5,10) // [5, 6, 7, 8, 9, 10]range(10,5) // [10, 9, 8, 7, 6, 5]range(10,2,2) // [10, 8, 6, 4, 2]range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselvesrange(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]range(5,10,0,-2) // [7, 8]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(Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1) to put it simpler (difference* offset in both direction/step)new Array(length).fill(0); check here[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 versastartingPoint + stepSize * index will gives us the value we need--- 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);
If, on Visual Studio Code, you faced the error:
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
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 ]
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);
}
Array.from to convert generators to array instances and inspect the output. –
Bullfighter 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.
range(start,end,step): With ES6 IteratorsYou 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)
}
R.range as does LodashNot implemented yet!
Using the new Number.range proposal (stage 2):
[...Number.range(1, 10)]
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
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]
(from, to) => [...Array(to - from)].map((_,i)=> i + from)
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)
))
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})}
const range = (a, b) => (a>=b) ? [] : [a, ...range(a+1, b)], using ES6 syntax –
Cadastre const range = (a, b, Δ = 1) => (a > b) ? [] : [a, ...range(a + Δ, b, Δ)];. Also upvoting the whole answer for the comment. –
Siena 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]
My personal favorite:
const range = (start, end) => new Array(end-start+1).fill().map((el, ind) => ind + start);
[...Array(end-start+1)].map((el, ind) => ind + start); ? –
Butterscotch ES6
Use Array.from (docs here):
const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));
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
);
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"] –
Niemi new keyword –
Lobectomy 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.
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]
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]
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 ]
As far as generating a numeric array for a given range, I use this:
function range(start, stop)
{
var array = [];
var length = stop - start;
for (var i = 0; i <= length; i++) {
array[i] = start;
start++;
}
return array;
}
console.log(range(1, 7)); // [1,2,3,4,5,6,7]
console.log(range(5, 10)); // [5,6,7,8,9,10]
console.log(range(-2, 3)); // [-2,-1,0,1,2,3]
Obviously, it won't work for alphabetical arrays.
array = [] inside the loop may not give you what you want. –
Vanegas [5, 6, 7, 8, 9, 10, 11, 12, 13, 14], I would expect only the first half of that array. –
Vanegas You can use following one-liner to keep things short and simple
var start = 4;
var end = 20;
console.log(Array(end - start + 1).fill(start).map((x, y) => x + y));Use this. It creates an array with given amount of values (undefined), in the following example there are 100 indexes, but it is not relevant as here you need only the keys. It uses in the array, 100 + 1, because the arrays are always 0 index based. So if it's given 100 values to generate, the index starts from 0; hence the last value is always 99 not 100.
range(2, 100);
function range(start, end) {
console.log([...Array(end + 1).keys()].filter(value => end >= value && start <= value ));
}Using Harmony generators, supported by all browsers except IE11:
var take = function (amount, generator) {
var a = [];
try {
while (amount) {
a.push(generator.next());
amount -= 1;
}
} catch (e) {}
return a;
};
var takeAll = function (gen) {
var a = [],
x;
try {
do {
x = a.push(gen.next());
} while (x);
} catch (e) {}
return a;
};
var range = (function (d) {
var unlimited = (typeof d.to === "undefined");
if (typeof d.from === "undefined") {
d.from = 0;
}
if (typeof d.step === "undefined") {
if (unlimited) {
d.step = 1;
}
} else {
if (typeof d.from !== "string") {
if (d.from < d.to) {
d.step = 1;
} else {
d.step = -1;
}
} else {
if (d.from.charCodeAt(0) < d.to.charCodeAt(0)) {
d.step = 1;
} else {
d.step = -1;
}
}
}
if (typeof d.from === "string") {
for (let i = d.from.charCodeAt(0); (d.step > 0) ? (unlimited ? true : i <= d.to.charCodeAt(0)) : (i >= d.to.charCodeAt(0)); i += d.step) {
yield String.fromCharCode(i);
}
} else {
for (let i = d.from; (d.step > 0) ? (unlimited ? true : i <= d.to) : (i >= d.to); i += d.step) {
yield i;
}
}
});
take
Example 1.
take only takes as much as it can get
take(10, range( {from: 100, step: 5, to: 120} ) )
returns
[100, 105, 110, 115, 120]
Example 2.
to not neccesary
take(10, range( {from: 100, step: 5} ) )
returns
[100, 105, 110, 115, 120, 125, 130, 135, 140, 145]
takeAll
Example 3.
from not neccesary
takeAll( range( {to: 5} ) )
returns
[0, 1, 2, 3, 4, 5]
Example 4.
takeAll( range( {to: 500, step: 100} ) )
returns
[0, 100, 200, 300, 400, 500]
Example 5.
takeAll( range( {from: 'z', to: 'a'} ) )
returns
["z", "y", "x", "w", "v", "u", "t", "s", "r", "q", "p", "o", "n", "m", "l", "k", "j", "i", "h", "g", "f", "e", "d", "c", "b", "a"]
for clause would improve readability here. –
Dagmardagna ... more range, using a generator function.
function range(s, e, str){
// create generator that handles numbers & strings.
function *gen(s, e, str){
while(s <= e){
yield (!str) ? s : str[s]
s++
}
}
if (typeof s === 'string' && !str)
str = 'abcdefghijklmnopqrstuvwxyz'
const from = (!str) ? s : str.indexOf(s)
const to = (!str) ? e : str.indexOf(e)
// use the generator and return.
return [...gen(from, to, str)]
}
// usage ...
console.log(range('l', 'w'))
//=> [ 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w' ]
console.log(range(7, 12))
//=> [ 7, 8, 9, 10, 11, 12 ]
// first 'o' to first 't' of passed in string.
console.log(range('o', 't', "ssshhhooooouuut!!!!"))
// => [ 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 't' ]
// only lowercase args allowed here, but ...
console.log(range('m', 'v').map(v=>v.toUpperCase()))
//=> [ 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V' ]
// => and decreasing range ...
console.log(range('m', 'v').map(v=>v.toUpperCase()).reverse())
// => ... and with a step
console.log(range('m', 'v')
.map(v=>v.toUpperCase())
.reverse()
.reduce((acc, c, i) => (i % 2) ? acc.concat(c) : acc, []))
// ... etc, etc.
Hope this is useful.
My codegolfing coworker came up with this (ES6), inclusive:
(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)
non inclusive:
(s,f)=>[...Array(f-s)].map((e,i)=>i+s)
you can use lodash function _.range(10) https://lodash.com/docs#range
Complete ES6 implementation using range([start, ]stop[, step]) signature:
function range(start, stop, step=1){
if(!stop){stop=start;start=0;}
return Array.from(new Array(int((stop-start)/step)), (x,i) => start+ i*step)
}
If you want automatic negative stepping, add
if(stop<start)step=-Math.abs(step)
Or more minimalistically:
range=(b, e, step=1)=>{
if(!e){e=b;b=0}
return Array.from(new Array(int((e-b)/step)), (_,i) => b<e? b+i*step : b-i*step)
}
If you have huge ranges look at Paolo Moretti's generator approach
!stop with typeof stop === 'undefined', then replace int with Math.floor, and add a check if (start > stop && step > 0) (otherwise, range(-3, -10) throws an exception instead of doing something sane (either flipping the sign of step or returning [])). Otherwise, good! –
Metalware You can also use a generator to produce the sequence. The difference is that each value in the sequence is lazy loaded. spread operator and for of works for the result. The asterisk symbols makes the function to be a generator.
const range = function*(from,to) {
for(let i = from; i <= to; i++) yield I;
};
[...range(3,5)]// => [3, 4, 5]
Op asked for a range, say range(3, 10), so it can be
[...[...Array(10-3).keys()].map(i => i+3)]
returns
[3, 4, 5, 6, 7, 8, 9]
Here's a nice short way to do it in ES6 with numbers only (don't know its speed compares):
Array.prototype.map.call(' '.repeat(1 + upper - lower), (v, i) => i + lower)
For a range of single characters, you can slightly modify it:
Array.prototype.map.call(' '.repeat(1 + upper.codePointAt() - lower.codePointAt()), (v, i) => String.fromCodePoint(i + lower.codePointAt()));
Array(1 + upper - lower).fill().map((v, i) => i + lower) –
Brainwork There's an npm module bereich for that ("bereich" is the German word for "range"). It makes use of modern JavaScript's iterators, so you can use it in various ways, such as:
console.log(...bereich(1, 10));
// => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
const numbers = Array.from(bereich(1, 10));
// => [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
for (const number of bereich(1, 10)) {
// ...
}
It also supports descending ranges (by simply exchanging min and max), and it also supports steps other than 1.
Disclaimer: I am the author of this module, so please take my answer with a grain of salt.
Javascript provides a function to create and fill an array from given values, receiving the container array and a map function as parameters:
let arr = Array.from(SOURCE_ARRAY, MAP_FUNCTION);
Since the MAP_FUNCTION provides the value and index for the iteration, it's possible to create an empty array (SOURCE_ARRAY) and fill it using indexes, like this (supossing 10 is your desired lenght):
let arr = Array.from(Array(10), (n, index) => index);
Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].
I did a review of the answers here, and noticed the following points:
let arr = Array.from( {length:3} ); // gives [null,null,null]arr.map( (e,i) => i ); // gives [0,1,2]from..to requirement.
arr.map( (e,i) => i+1 ); // gives [1,2,3]charCodeAt and fromCharCode was needed to map the string to a number then back to a string again.
arr.map( (e,i) => String.fromCharCode( i+"A".charCodeAt(0) ); // gives ["A","B","C"]There are some simple to some fancy implementations based on some or all of the above. The answers got complicated when they try to pack both the integer and string solutions into a single function. For me, I elected to implement integer and string solutions in their own functions. I justify this because, in practice, you will know what your use case is and you will use the appropriate function directly. I also supply the wrapper function if you want to call it indirectly.
let rangeInt = (from,to) => Array.from( { length: to-from+1 }, (e, i) => i + from );
let rangeChar = (from,to) => Array.from( { length: to.charCodeAt(0)-from.charCodeAt(0)+1 }, (e,i) => String.fromCharCode(i+from.charCodeAt(0)) );
let range = (from,to) =>
(typeof(from) === 'string' && typeof(to) === 'string')
? rangeChar(from,to)
: (!to) ? rangeInt(0,from-1) : rangeInt(from,to);
console.log( rangeInt(1,3) ); // gives [1,2,3]
console.log( rangeChar("A","C") ); // gives ["A","B","C"]
console.log( range(1,3) ); // gives [1,2,3]
console.log( range("A","C") ); // gives ["A","B","C"]
console.log( range(3) ); // gives [0,1,2]I was surprised to come across this thread and see nothing like my solution (maybe I missed an answer), so here it is. I use a simple range function in ES6 syntax :
// [begin, end[
const range = (b, e) => Array.apply(null, Array(e - b)).map((_, i) => {return i+b;});
But it works only when counting forward (ie. begin < end), so we can modify it slightly when needed like so :
const range = (b, e) => Array.apply(null, Array(Math.abs(e - b))).map((_, i) => {return b < e ? i+b : b-i;});
[...Array(e-b)] while you are at it. –
Disability You can also do the following:
const range = Array.from(Array(size)).map((el, idx) => idx+1).slice(begin, end);
None of the examples had tests, implementation for step with an option to produce decreasing values.
export function range(start = 0, end = 0, step = 1) {
if (start === end || step === 0) {
return [];
}
const diff = Math.abs(end - start);
const length = Math.ceil(diff / step);
return start > end
? Array.from({length}, (value, key) => start - key * step)
: Array.from({length}, (value, key) => start + key * step);
}
Tests:
import range from './range'
describe('Range', () => {
it('default', () => {
expect(range()).toMatchObject([]);
})
it('same values', () => {
expect(range(1,1)).toMatchObject([]);
})
it('step=0', () => {
expect(range(0,1,0)).toMatchObject([]);
})
describe('step=1', () => {
it('normal', () => {
expect(range(6,12)).toMatchObject([6, 7, 8, 9, 10, 11]);
})
it('reversed', () => {
expect(range(12,6)).toMatchObject([12, 11, 10, 9, 8, 7]);
})
})
describe('step=5', () => {
it('start 0 end 60', () => {
expect(range(0, 60, 5)).toMatchObject([0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55]);
})
it('reversed start 60 end -1', () => {
expect(range(55, -1, 5)).toMatchObject([55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0]);
})
})
})
Keeping it simple:
// Generator
function* iter(a, b, step = 1) {
for (let i = b ? a : 0; i < (b || a); i += step) {
yield i
}
}
const range = (a, b, step = 1) =>
typeof a === 'string'
? [...iter(a.charCodeAt(), b.charCodeAt() + 1)].map(n => String.fromCharCode(n))
: [...iter(a, b, step)]
range(4) // [0, 1, 2, 3]
range(1, 4) // [1, 2, 3]
range(2, 20, 3) // [2, 5, 8, 11, 14, 17]
range('A', 'C') // ['A', 'B', 'C']
.fromCharCode(). –
Pennywise In order to work where either given number could be larger I wrote this:
function getRange(start, end) {
return Array.from({
length: 1 + Math.abs(end - start)
}, (_, i) => end > start ? start + i : start - i);
}
You can create your own es6 range version
const range = (min, max) => {
const arr = Array(max - min + 1)
.fill(0)
.map((_, i) => i + min);
return arr;
}
console.log(range(0,5));
console.log(range(2,8))Here is the way to implment your own iterable range function.
// implementing range
function range(start, end){
return {
from: start,
to: end,
[Symbol.iterator]() {
this.current = this.from;
return this;
},
next() {
if (this.current <= this.to) {
return { done: false, value: this.current++ };
} else {
return { done: true };
}
}
};
}
// iterate over each value
for (let num of range(1,5)) {
console.log(num); // 1, 2, 3, 4, 5
}A recursive solution to generating integer array within bounds.
function intSequence(start, end, n = start, arr = []) {
return (n === end) ? arr.concat(n)
: intSequence(start, end, start < end ? n + 1 : n - 1, arr.concat(n));
}
$> intSequence(1, 1)
<- Array [ 1 ]
$> intSequence(1, 3)
<- Array(3) [ 1, 2, 3 ]
$> intSequence(3, -3)
<- Array(7) [ 3, 2, 1, 0, -1, -2, -3 ]
For function that behaves like python range() function, use this:
function range(min=0, max=null){
if(max === null){
max=min;
min=0;
}
var rg=[...Array(max).keys()];
return rg.slice(min,max);
}
My favorite is the generator generateRange with another function getRange to run the generator.
An advantage of this compared to many other solutions is that unnecessary arrays are not created multiple times.
function* generateRange(start, end, step = 1) {
let current = start;
while (start < end ? current <= end : current >= end) {
yield current;
current = start < end ? current + step : current - step;
}
}
function getRange(start, end, step = 1) {
return [...generateRange(start, end, step)];
}
console.log(getRange(0, 5)) // [ 0, 1, 2, 3, 4, 5 ]
console.log(getRange(10, 0, 2)) // [ 10, 8, 6, 4, 2, 0 ]
for (let i of generateRange(5,10)){console.log(i)} –
Boylston The closest I have found is with the radash library:
import { range } from 'radash'
for (let i of range(1, 5)) {
console.log(i)
}
See documentation here:
I found a JS range function equivalent to the one in PHP, and works amazingly great here. Works forward & backward, and works with integers, floats and alphabets!
function range(low, high, step) {
// discuss at: http://phpjs.org/functions/range/
// original by: Waldo Malqui Silva
// example 1: range ( 0, 12 );
// returns 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
// example 2: range( 0, 100, 10 );
// returns 2: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
// example 3: range( 'a', 'i' );
// returns 3: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
// example 4: range( 'c', 'a' );
// returns 4: ['c', 'b', 'a']
var matrix = [];
var inival, endval, plus;
var walker = step || 1;
var chars = false;
if (!isNaN(low) && !isNaN(high)) {
inival = low;
endval = high;
} else if (isNaN(low) && isNaN(high)) {
chars = true;
inival = low.charCodeAt(0);
endval = high.charCodeAt(0);
} else {
inival = (isNaN(low) ? 0 : low);
endval = (isNaN(high) ? 0 : high);
}
plus = ((inival > endval) ? false : true);
if (plus) {
while (inival <= endval) {
matrix.push(((chars) ? String.fromCharCode(inival) : inival));
inival += walker;
}
} else {
while (inival >= endval) {
matrix.push(((chars) ? String.fromCharCode(inival) : inival));
inival -= walker;
}
}
return matrix;
}
And here is the minified version:
function range(h,c,b){var i=[];var d,f,e;var a=b||1;var g=false;if(!isNaN(h)&&!isNaN(c)){d=h;f=c}else{if(isNaN(h)&&isNaN(c)){g=true;d=h.charCodeAt(0);f=c.charCodeAt(0)}else{d=(isNaN(h)?0:h);f=(isNaN(c)?0:c)}}e=((d>f)?false:true);if(e){while(d<=f){i.push(((g)?String.fromCharCode(d):d));d+=a}}else{while(d>=f){i.push(((g)?String.fromCharCode(d):d));d-=a}}return i};
For a more ruby-like approach with good backward compatibility:
range([begin], end = 0) where begin and end are numbers
var range = function(begin, end) {
if (typeof end === "undefined") {
end = begin; begin = 0;
}
var result = [], modifier = end > begin ? 1 : -1;
for ( var i = 0; i <= Math.abs(end - begin); i++ ) {
result.push(begin + i * modifier);
}
return result;
}
Examples:
range(3); //=> [0, 1, 2, 3]
range(-2); //=> [0, -1, -2]
range(1, 2) //=> [1, 2]
range(1, -2); //=> [1, 0, -1, -2]
typeof on a variable guaranteed to be set can be replaced with a strict equality check with undefined or void 0 if you're paranoid and not in strict mode. –
Vanegas Here is my solution that mimics Python. At the bottom you can find some examples how to use it. It works with numbers, just like Python's range:
var assert = require('assert'); // if you use Node, otherwise remove the asserts
var L = {}; // L, i.e. 'list'
// range(start, end, step)
L.range = function (a, b, c) {
assert(arguments.length >= 1 && arguments.length <= 3);
if (arguments.length === 3) {
assert(c != 0);
}
var li = [],
i,
start, end, step,
up = true; // Increasing or decreasing order? Default: increasing.
if (arguments.length === 1) {
start = 0;
end = a;
step = 1;
}
if (arguments.length === 2) {
start = a;
end = b;
step = 1;
}
if (arguments.length === 3) {
start = a;
end = b;
step = c;
if (c < 0) {
up = false;
}
}
if (up) {
for (i = start; i < end; i += step) {
li.push(i);
}
} else {
for (i = start; i > end; i += step) {
li.push(i);
}
}
return li;
}
Examples:
// range
L.range(0) -> []
L.range(1) -> [0]
L.range(2) -> [0, 1]
L.range(5) -> [0, 1, 2, 3, 4]
L.range(1, 5) -> [1, 2, 3, 4]
L.range(6, 4) -> []
L.range(-2, 2) -> [-2, -1, 0, 1]
L.range(1, 5, 1) -> [1, 2, 3, 4]
L.range(0, 10, 2) -> [0, 2, 4, 6, 8]
L.range(10, 2, -1) -> [10, 9, 8, 7, 6, 5, 4, 3]
L.range(10, 2, -2) -> [10, 8, 6, 4]
// range() 0..10, step=1
// range(max) 0..max, step=1
// range(min,max) min..max, step=1
// range(min,step,max) min..max, step=step
// Use:
// console.log(...range(3));
// Array.from(range(5))
// [...range(100)]
// for (const v of range(1,10)) { ...
function* range(...args) {
let [min, step, max] = {
0: [0, 1, 10],
1: [0, args[0] >= 0 ? 1 : -1, args[0]],
2: [args[0], args[1] >= args[0] ? 1 : -1, args[1]],
3: args,
}[args.length] || [];
if (min === undefined) throw new SyntaxError("Too many arguments");
let x = min;
while (step >= 0 ? x < max : x > max) {
yield x;
x += step
}
}
console.log(...range()); // 0 1 2 3 4 5 6 7 8 9
console.log(...range(3)); // 0 1 2
console.log(...range(2, 5)); // 2 3 4
console.log(...range(5, 2)); // 5 4 3
console.log(...range(3, -3)); // 3 2 1 0 -1 -2
console.log(...range(-3, 3)); // -3 -2 -1 0 1 2
console.log(...range(-5, -2));// -5 -4 -3
console.log(...range(-2, -5));// -2 -3 -4
Per my understanding:
function range(start, end, step = 1) {
const _range = _start => f => {
if (_start < end) {
f(_start);
setTimeout(() => _range(_start + step)(f), 0);
}
}
return {
map: _range(start),
};
}
range(0, 50000).map(console.log);
This function doesn't raise the aforementioned concerns.
I just created this polyfill on the Array via Object.defineProperty to make a range for integers or strings. The Object.defineProperty is a safer way to create polyfills.
The safer polyfill
if (!Array.range) {
Object.defineProperty(Array, 'range', {
value: function (from, to, step) {
if (typeof from !== 'number' && typeof from !== 'string') {
throw new TypeError('The first parameter should be a number or a character')
}
if (typeof to !== 'number' && typeof to !== 'string') {
throw new TypeError('The second parameter should be a number or a character')
}
var A = []
if (typeof from === 'number') {
A[0] = from
step = step || 1
while (from + step <= to) {
A[A.length] = from += step
}
} else {
var s = 'abcdefghijklmnopqrstuvwxyz'
if (from === from.toUpperCase()) {
to = to.toUpperCase()
s = s.toUpperCase()
}
s = s.substring(s.indexOf(from), s.indexOf(to) + 1)
A = s.split('')
}
return A
}
})
} else {
var errorMessage = 'DANGER ALERT! Array.range has already been defined on this browser. '
errorMessage += 'This may lead to unwanted results when Array.range() is executed.'
console.log(errorMessage)
}
Examples
Array.range(1, 3)
// Return: [1, 2, 3]
Array.range(1, 3, 0.5)
// Return: [1, 1.5, 2, 2.5, 3]
Array.range('a', 'c')
// Return: ['a', 'b', 'c']
Array.range('A', 'C')
// Return: ['A', 'B', 'C']
Array.range(null)
Array.range(undefined)
Array.range(NaN)
Array.range(true)
Array.range([])
Array.range({})
Array.range(1, null)
// Return: Uncaught TypeError: The X parameter should be a number or a character
Array –
Hose typeof from === typeof to –
Buckram Pythonic styled way:
range = (start, end, step) => {
let arr = []
for(let n=start;n<end;n+=(step||1)) arr.push(n)
return arr;
}
One liner that can work in either direction:
const range = (a,b)=>Array(Math.abs(a-b)+1).fill(a).map((v,i)=>v+i*(a>b?-1:1));
See in action:
const range = (a,b) => Array(Math.abs(a-b)+1).fill(a).map((v,i)=>v+i*(a>b?-1:1));
console.log(range(1,4));
console.log(range(4,1));There is already very good answers given, but I did not see complete usage of ES6 iterator utilized to achieve full implementation of range, so here it is:
/**
* inspired by Python's built-in range utility function
* implemented using ES6 Iterable, Iterator protolols (interfaces)
*/
class Range {
constructor(...args) {
this.start = args.length <= 1 ? 0 : args[0];
this.end = args.length <= 1 ? args[0] || 0 : args[1];
this.step = args.length <= 2 ? 1 : args[2];
}
[Symbol.iterator]() {
return this;
}
next() {
if (this.end > this.start) {
const result = { done: false, value: this.start };
this.start = this.start + this.step;
return result;
} else return { done: true, value: undefined };
}
}
/**
* Symbol.iterator is part of the couple of inbuilt symbols
* available in JavaScript. It allows for hooking into the
* inbuilt for of iteration mechanism. This is why the
* Symbol.iterator comes into play when talking about
* iterables and iterators in JavaScript.
*/
function range(...args) {
return new Range(...args);
}
console.log([...range(4)]); // [0, 1, 2, 3]
console.log([...range(2, 5)]); // [2, 3, 4]
console.log([...range(1, 10, 3)]); // [1, 4, 7]
I am sharing my implementation in case it may help someone.
function Range(start_or_num, end = null, increment = 1) {
const end_check = end === null
const start = end_check ? 0 : start_or_num
const count = end_check ? start_or_num : Math.round((end - start) / increment) + 1
const filterFunc = end_check ? x => x >= start : x => x < end && x >= start
return [...Array.from(
Array(count).keys(), x => increment * (x - 1) + start
)
].filter(filterFunc)
}
// usage
// console.log(Range(4, 10, 2)) // [4, 6, 8]
// console.log(Range(5, 10 )) //[5, 6, 7, 8, 9]
// console.log(Range(10 ))// [0, 1, 2, 3, 4, 5, 6, 7, 8]
Array(count).keys() to {length: count}, and edit the .from map fn from using arg x to use args (_, x) - itll save you creating a duplicate array and its corresponding iterator –
Corneille handle ranges that run in either ascending or descending order:
const range = (start, end) => (
(end > start)
? [...Array((end - start + 1)).keys()].map((k) => (k + start))
: [...Array((start - end + 1)).keys()].map((k) => (k + end)).reverse()
);
console.log(range(3, 5));
console.log(range(5, 3));If you need a "Large Range". For speed you can use TypedArray:
// Fast Range with TypedArray:
Object.getPrototypeOf(Uint8Array).Range=function(start,stop,step=1){
if(stop==null){stop=start;start=0;}
let l=Math.ceil((stop-start)/step),arr=new this(l);
for(let i=0;i<l;i++)arr[i]=start+i*step;
return arr};
// Usage:
let rangeA=Uint8Array.Range(5);
let rangeB=Int16Array.Range(-250,250,100);
let rangeC=Float64Array.Range(0,.5,.1);
console.log(rangeA,rangeB,rangeC);Int8Array -128 to 127
Uint8Array 0 to 255
Uint8ClampedArray 0 to 255
Int16Array -32768 to 32767
Uint16Array 0 to 65535
Int32Array -2147483648 to 2147483647
Uint32Array 0 to 4294967295
Float32Array -3.4e38 to 3.4e38
Float64Array -1.8e308 to 1.8e308
BigInt64Array -2**63 to 2**63-1
BigUint64Array 0 to 2**64-1
Speed comparison:
Object.getPrototypeOf(Uint8Array).Range=function(start,stop,step=1){
if(stop==null){stop=start;start=0;}
let l=Math.ceil((stop-start)/step),arr=new this(l);
for(let i=0;i<l;i++)arr[i]=start+i*step;
return arr;};
Object.getPrototypeOf(Array).Range=function(start,stop,step=1){
if(stop==null){stop=start;start=0;}
let l=Math.ceil((stop-start)/step),arr=new this(l);
for(let i=0;i<l;i++)arr[i]=start+i*step;
return arr;};
// Speed comparison:
let rsize=10**8,range;
console.time('Array Range');
range=Array.Range(rsize);
console.timeEnd('Array Range'); // Array Range: 3008.181 ms
console.time('TypedArray Range');
range=Uint32Array.Range(rsize);
console.timeEnd('TypedArray Range'); // TypedArray Range: 256.283 msOr see on https://jsben.ch/uaEvH
If you need "Iterator":
let range=function*(start,stop,step=1){
if(stop==null){stop=start;start=0;}
let l=Math.ceil((stop-start)/step);
for(let i=0;i<l;i++)yield start+i*step;
};
for(let i of range(4))console.log(i);If you need "String Range":
String.Range=function(start,stop){
if(stop==null){stop=start;start='a';}
start=start.charCodeAt(0),stop=stop.charCodeAt(0);
let l=stop-start+1,buffer=new ArrayBuffer(l),view=new Uint8Array(buffer);
for(let i=0;i<l;i++)view[i]=start+i;
return new TextDecoder("utf-8").decode(buffer);
};
console.log(String.Range('A','D')); // ABCDSolution:
//best performance
var range = function(start, stop, step) {
var a = [start];
while (start < stop) {
start += step || 1;
a.push(start);
}
return a;
};
//or
var range = function(start, end) {
return Array(++end-start).join(0).split(0).map(function(n, i) {
return i+start
});
}
step to a default value outside of the loop. –
Vanegas My take using conditional ternary operators in the for loop (no argument testing, though).
function range(start,end,step){
var resar = [];
for (var i=start;(step<0 ? i>=end:i<=end); i += (step == undefined ? 1:step)){
resar.push(i);
};
return resar;
};
If we input something like [4, 2], we’ll get [2, 3, 4] as output, we can work with that.
function createRange(array) {
var range = [];
var highest = array.reduce(function(a, b) {
return Math.max(a, b);
});
var lowest = array.reduce(function(a, b) {
return Math.min(a, b);
});
for (var i = lowest; i <= highest; i++) {
range.push(i);
}
return range;
}
var highest = Math.max.apply(null, array). –
Vanegas Math.max(...array) –
Vanegas [4, 2] should return sequence [4, 3, 2]. BTW, it assumes the input array might be any length but you pick only two values (array.reduce is an overkill in this case), suppose createRange(a, b) would be more handy here –
Thomas Coded to 2010 specs (ya, it is 2016 with ES6 generators). Here's my take, with options to emulate the Python's range() function.
Array.range = function(start, end, step){
if (start == undefined) { return [] } // "undefined" check
if ( (step === 0) ) { return []; // vs. throw TypeError("Invalid 'step' input")
} // "step" == 0 check
if (typeof start == 'number') { // number check
if (typeof end == 'undefined') { // single argument input
end = start;
start = 0;
step = 1;
}
if ((!step) || (typeof step != 'number')) {
step = end < start ? -1 : 1;
}
var length = Math.max(Math.ceil((end - start) / step), 0);
var out = Array(length);
for (var idx = 0; idx < length; idx++, start += step) {
out[idx] = start;
}
// Uncomment to check "end" in range() output, non pythonic
if ( (out[out.length-1] + step) == end ) { // "end" check
out.push(end)
}
} else {
// Historical: '&' is the 27th letter: http://nowiknow.com/and-the-27th-letter-of-the-alphabet/
// Axiom: 'a' < 'z' and 'z' < 'A'
// note: 'a' > 'A' == true ("small a > big A", try explaining it to a kid! )
var st = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&'; // axiom ordering
if (typeof end == 'undefined') { // single argument input
end = start;
start = 'a';
}
var first = st.indexOf(start);
var last = st.indexOf(end);
if ((!step) || (typeof step != 'number')) {
step = last < first ? -1 : 1;
}
if ((first == -1) || (last == -1 )) { // check 'first' & 'last'
return []
}
var length = Math.max(Math.ceil((last - first) / step), 0);
var out = Array(length);
for (var idx = 0; idx < length; idx++, first += step) {
out[idx] = st[first];
}
// Uncomment to check "end" in range() output, non pythonic
if ( (st.indexOf(out[out.length-1]) + step ) == last ) { // "end" check
out.push(end)
}
}
return out;
}
Example:
Array.range(5); // [0,1,2,3,4,5]
Array.range(4,-4,-2); // [4, 2, 0, -2, -4]
Array.range('a','d'); // ["a", "b", "c", "d"]
Array.range('B','y'); // ["B", "A", "z", "y"], different from chr() ordering
Array.range('f'); // ["a", "b", "c", "d", "e", "f"]
Array.range(-5); // [], similar to python
Array.range(-5,0) // [-5,-4-,-3-,-2,-1,0]
For letters, he's a simple vanilla JS solution I came up with to generate letter ranges. It's intended to generate arrays of upper- or lowercase letters, only.
function range(first, last) {
var r = [],
i = first.charCodeAt(0);
while(i <= last.charCodeAt(0)) {
r.push(String.fromCharCode(i++));
}
return r;
}
console.dir(range("a", "f"));
console.dir(range("G", "Z"));I would like to add what I would think is a very adjustable version, which is very fast.
const range = (start, end) => {
let all = [];
if (typeof start === "string" && typeof end === "string") {
// Return the range of characters using utf-8 least to greatest
const s = start.charCodeAt(0);
const e = end.charCodeAt(0);
for (let i = s; i <= e; i++) {
all.push(String.fromCharCode(i));
}
} else if (typeof start === "number" && typeof end === "number") {
// Return the range of numbers from least to greatest
for(let i = end; i >= start; i--) {
all.push(i);
}
} else {
throw new Error("Did not supply matching types number or string.");
}
return all;
}
// usage
const aTod = range("a", "d");
Also Typescript if you would like
const range = (start: string | number, end: string | number): string[] | number[] => {
const all: string[] | number[] = [];
if (typeof start === "string" && typeof end === "string") {
const s: number = start.charCodeAt(0);
const e: number = end.charCodeAt(0);
for (let i = s; i <= e; i++) {
all.push(String.fromCharCode(i));
}
} else if (typeof start === "number" && typeof end === "number") {
for (let i = end; i >= start; i--) {
all.push(i);
}
} else {
throw new Error("Did not supply matching types number or string.");
}
return all;
}
// Usage
const negTenToten: number[] = range(-10, 10) as number[];
Made with some influence from other answers. User is gone now.
Array.prototype.reverse() is expensive though for any decently long range. –
Vanegas < | > | === | logic would be rather simple. I did say easily adjustable. –
Nonintervention Here is a simple approach based on @benmcdonald and others, more than one line though...
let K = [];
for (i = 'A'.charCodeAt(0); i <= 'Z'.charCodeAt(0); i++) {
K.push(String.fromCharCode(i))
};
console.log(K);Here is a definition of a range function that behaves exactly like Python's range type except that this one is not lazy. It should be easy to turn it into a generator.
The arguments to the range constructor must be numbers. If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. If step is zero, an error is raised.
range = (start, stop, step=1) => {
if(step === 0) throw new Error("range() arg 3 must not be zero");
const noStart = stop == null;
stop = noStart ? start : stop;
start = noStart ? 0 : start;
const length = Math.ceil(((stop - start) / step));
return Array.from({length}, (_, i) => (i * step) + start);
}
console.log(range(-10, 10, 2));
//output [Array] [-10,-8,-6,-4,-2,0,2,4,6,8]
console.log(range(10));
// [Array] [0,1,2,3,4,5,6,7,8,9]
console.log(3, 12);
// [Array] [3,4,5,6,7,8,9,10,11]
A range with a defined hard int has a ton of answers, but what if you don't know that step and you want a number of steps in-between instead?
I wrote this code to do that. It's pretty self-explanatory.
const stepScale = (min, max, numberOfSteps) => {
const _numberOfSteps = numberOfSteps - 1
const scaleBy = (max - min) / _numberOfSteps
const arr = []
for (let i = 0; i <= _numberOfSteps; i += 1) {
arr.push(min + scaleBy * i)
}
return arr
}
export default stepScale
stepScale(5, 10, 4)
// [5, 6.666666666666667, 8.333333333333334, 10]
For npm at https://npm.im/@universalstandard/step-scale
My implementation
export function stringRange(a: string, b: string) {
let arr = [a + ''];
const startPrefix = a.match(/([\D])+/g);
const endPrefix = b.match(/([\D])+/g);
if ((startPrefix || endPrefix) && (Array.isArray(startPrefix) && startPrefix[0]) !== (Array.isArray(endPrefix) && endPrefix[0])) {
throw new Error('Series number does not match');
}
const startNum = a.match(/([\d])+/g);
const endNum = b.match(/([\d])+/g);
if (!startNum || !endNum) {
throw new Error('Range is not valid');
}
let start = parseInt(startNum[0], 10);
let end = parseInt(endNum[0], 10);
if (start > end) {
throw new Error('Ending value should be lessesr that starting value');
}
while (start !== end) {
start++;
arr.push(startPrefix ? startPrefix[0] + (start + '').padStart(startNum[0].length, '0') : start + '');
}
return arr;
}
Sample Result
// console.log(range('0', '10'));
// console.log(range('10', '10'));
// console.log(range('10', '20'));
// console.log(range('10', '20000'));
// console.log(range('ABC10', 'ABC23'));
// console.log(range('ABC10', 'ABC2300'));
// console.log(range('ABC10', 'ABC09')); --> Failure case
// console.log(range('10', 'ABC23')); --> Failure case
// console.log(range('ABC10', '23')); --> Failure case
Setup with TypeScript (app wide):
declare global {
interface Function {
range(count: number, start_with: number): number[];
}
}
Function.prototype.range = function (
count: number,
start_with: number = 0
): number[] {
return [...Array(count).keys()].map((key) => key + start_with);
};
Setup with JS:
Function.prototype.range = function(count, start_with=0){
return [...Array(count).keys()].map((key) => key + start_with);
}
Use example:
Function.range(2,0) //Will return [0,1]
Function.range(2,1) //Will return [1,2]
Function.range(2,-1) //Will return [-1,0]
/**
* @param {!number|[!number,!number]} sizeOrRange Can be the `size` of the range (1st signature) or a
* `[from, to]`-shape array (2nd signature) that represents a pair of the *starting point (inclusive)* and the
* *ending point (exclusive)* of the range (*mathematically, a left-closed/right-open interval: `[from, to)`*).
* @param {!number} [fromOrStep] 1st signature: `[from=0]`. 2nd signature: `[step=1]`
* @param {!number} [stepOrNothing] 1st signature: `[step=1]`. 2nd signature: NOT-BEING-USED
* @example
* range(5) ==> [0, 1, 2, 3, 4] // size: 5
* range(4, 5) ==> [5, 6, 7, 8] // size: 4, starting from: 5
* range(4, 5, 2) ==> [5, 7, 9, 11] // size: 4, starting from: 5, step: 2
* range([2, 5]) ==> [2, 3, 4] // [2, 5) // from: 2 (inclusive), to: 5 (exclusive)
* range([1, 6], 2) ==> [1, 3, 5] // from: 1, to: 6, step: 2
* range([1, 7], 2) ==> [1, 3, 5] // from: 1, to: 7 (exclusive), step: 2
* @see {@link https://mcmap.net/q/20881/-does-javascript-have-a-method-like-quot-range-quot-to-generate-a-range-within-the-supplied-bounds}
*/
export function range (sizeOrRange, fromOrStep, stepOrNothing) {
let from, to, step, size
if (sizeOrRange instanceof Array) { // 2nd signature: `range([from, to], step)`
[from, to] = sizeOrRange
step = fromOrStep ?? 1
size = Math.ceil((to - from) / step)
} else { // 1st signature: `range(size, from, step)`
size = sizeOrRange
from = fromOrStep ?? 0
step = stepOrNothing ?? 1
}
return Array.from({length: size}, (_, i) => from + i * step)
}
Examples:
console.log(
range(5), // [0, 1, 2, 3, 4] // size: 5
range([2, 5]), // [2, 3, 4] // [2, 5) // from: 2 (inclusive), to: 5 (exclusive)
range(4, 2), // [2, 3, 4, 5] // size: 4, starting from: 2
range([1, 6], 2), // [1, 3, 5] // from: 1, to: 6, step: 2
range([1, 7], 2), // [1, 3, 5] // from: 1, to: 7 (exclusive), step: 2
)<script>
function range (sizeOrRange, fromOrStep, stepOrNothing) {
let from, to, step, size
if (sizeOrRange instanceof Array) { // 2nd signature: `range([from, to], step)`
[from, to] = sizeOrRange
step = fromOrStep ?? 1
size = Math.ceil((to - from) / step)
} else { // 1st signature: `range(size, from, step)`
size = sizeOrRange
from = fromOrStep ?? 0
step = stepOrNothing ?? 1
}
return Array.from({ length: size }, (_, i) => from + i * step)
}
</script>A typescript function to closely replicate
/**
* Create a generator from 0 to stop, useful for iteration. Similar to range in Python.
* See: https://mcmap.net/q/20881/-does-javascript-have-a-method-like-quot-range-quot-to-generate-a-range-within-the-supplied-bounds
* See: https://docs.python.org/3/library/stdtypes.html#ranges
* @param {number | BigNumber} stop
* @returns {Iterable<number>}
*/
export function range(stop: number | BigNumber): Iterable<number>
/**
* Create a generator from start to stop, useful for iteration. Similar to range in Python.
* See: https://mcmap.net/q/20881/-does-javascript-have-a-method-like-quot-range-quot-to-generate-a-range-within-the-supplied-bounds
* See: https://docs.python.org/3/library/stdtypes.html#ranges
* @param {number | BigNumber} start
* @param {number | BigNumber} stop
* @returns {Iterable<number>}
*/
export function range(
start: number | BigNumber,
stop: number | BigNumber,
): Iterable<number>
/**
* Create a generator from start to stop while skipping every step, useful for iteration. Similar to range in Python.
* See: https://mcmap.net/q/20881/-does-javascript-have-a-method-like-quot-range-quot-to-generate-a-range-within-the-supplied-bounds
* See: https://docs.python.org/3/library/stdtypes.html#ranges
* @param {number | BigNumber} start
* @param {number | BigNumber} stop
* @param {number | BigNumber} step
* @returns {Iterable<number>}
*/
export function range(
start: number | BigNumber,
stop: number | BigNumber,
step: number | BigNumber,
): Iterable<number>
export function* range(a: unknown, b?: unknown, c?: unknown): Iterable<number> {
const getNumber = (val: unknown): number =>
typeof val === 'number' ? val : (val as BigNumber).toNumber()
const getStart = () => (b === undefined ? 0 : getNumber(a))
const getStop = () => (b === undefined ? getNumber(a) : getNumber(b))
const getStep = () => (c === undefined ? 1 : getNumber(c))
for (let i = getStart(); i < getStop(); i += getStep()) {
yield i
}
}
nope - still no native javascript range in 2002, but this concise ES6 arrow-function can provide ascending and descending numbers and strings just like PHP (including steps).
// @return ascending or descending range of numbers or strings
const range = (a,b,d=1) => typeof a === 'string'
? range(a.charCodeAt(),b.charCodeAt()).map(v=>String.fromCharCode(v))
: isNaN(b)
? range(0, a-1)
: b < a
? range(b, a, d).reverse()
: d > 1
? range(a, b).filter(v => v%d === 0)
: [a,b].reduce((min,max)=>Array(max+1-min).fill(min).map((v,i)=>v+i));
// Usage
console.assert(
range(3).toString() === '0,1,2' &&
range(2,4).toString() === '2,3,4' &&
range(4,2).toString() === '4,3,2' &&
range(5,15,5).toString() === '5,10,15' &&
range('A','C').toString() === 'A,B,C' &&
range('C','A').toString() === 'C,B,A'
);Try the Iterator.range stage 2 proposal's polyfill.
[...Iterator.range(0, 5)]; // [0, 1, 2, 3, 4]
const numStart = 1990;
const numEnd = 2020;
const numInRange = [...Array(numEnd - numStart + 1).keys()].map(i => i + numStart);
console.log(numInRange);Adding on to @fuji's answer, to set a lower bound, use .slice(lowerbound)
just made something like this as an exercise in Eloquent JavaScript
function range(start, end, step) {
var ar = [];
if (start < end) {
if (arguments.length == 2) step = 1;
for (var i = start; i <= end; i += step) {
ar.push(i);
}
}
else {
if (arguments.length == 2) step = -1;
for (var i = start; i >= end; i += step) {
ar.push(i);
}
}
return ar;
}
You can use a function with an array, a for loop, and a Math.random() variable to solve that. The for loop pushes numbers into the array, which will contain all the numbers in your range. Then the Math.random() randomly selects one, based on the array's length.
function randNumInRange(min, max) {
var range = []
for(var count = min; count <= max; count++) {
range.push(count);
}
var randNum = Math.floor(Math.random() * range.length);
alert(range[randNum]);
}
There isn't a native method. But you can do it with filter method of Array.
var range = (array, start, end) =>
array.filter((element, index)=>index>=start && index <= end)
alert( range(['a','h','e','l','l','o','s'],1,5) )
// ['h','e','l','l','o']array.slice(1,5). –
Undeviating slice() does not modify the original array. Maybe you're thinking of splice(). –
Vanegas I prefer the way below
var range = function(x, y) {
return Array(y - x+1).fill(x).map((a, b) => {return a+b}).filter(i => i >= x);
};
console.log(range(3, 10));This is what I use for numbers ranges:
const rangeFrom0 = end => [...Array(end)].map((_, index) => index);
or
const rangeExcEnd = (start, step, end) => [...Array(end - start + 1)]
.map((_, index) => index + start)
.filter(x => x % step === start % step);
Array.from(Array((m - n + 1)), (v, i) => n + i); // m > n and both of them are integers.
function range(firstNum, lastNum) {
let rangeList = [];
if (firstNum > lastNum) {
return console.error("First number cannot be bigger than last number");
}
let counter = firstNum;
while(counter <= lastNum) {
rangeList.push(counter);
counter++;
}
return rangeList;
}function check(){
var correct=true;
for(var i=0; i<arguments.length; i++){
if(typeof arguments[i] != "number"){
correct=false; } } return correct; }
//------------------------------------------
function range(start,step,end){
var correct=check(start,step,end);
if(correct && (step && end)!=0){
for(var i=start; i<=end; i+=step)
document.write(i+" "); }
else document.write("Not Correct Data"); }
check() missed a chance to short circuit and early return, 2. You have a few redundant variables, 3. Using document.write() makes the function pretty useless for most applications –
Vanegas Loop over a range of numbers between 0 and your Length in Vue:
<div v-for="index in range" />
computed: {
range () {
let x = [];
for (let i = 0; i < this.myLength; i++)
{
x.push(i);
}
return x;
}
}
© 2022 - 2024 — McMap. All rights reserved.
$Rfunction, but other than that I don't really think so. – OstioleArray.from("ABC") //['A', 'B', 'C']This is the closest thing I can find for the second part of the question. – Whimsicalsplit("")there also – VanegasArray.apply(null, { length: 10 }).map(eval.call, Number)– Easygoingconst 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], butrange(1,5)produces an empty array) – Cochard