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

Antwoord 10

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

Antwoord 11

— UPDATE (met dank aan @lokhmakov voor de vereenvoudiging) —

Een andere versie die ES6-generatoren gebruikt (zie het geweldige Paolo Moretti-antwoord met ES6-generatoren):

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

Of, als we alleen iterable nodig hebben, dan:

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

— ORIGINELE code was: —

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

en

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

Antwoord 12

Harmony spread-operatoren pijlfuncties gebruiken:

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

Voorbeeld:

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

Antwoord 13

Je kunt lodashof Undescore.jsrange:

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

Als u alleen een opeenvolgend bereik van gehele getallen nodig heeft, kunt u ook zoiets doen als:

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

In ES6 rangekan worden geïmplementeerd met generatoren:

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

Deze implementatie bespaart geheugen bij het herhalen van grote reeksen, omdat het niet alle waarden in een array hoeft te materialiseren:

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

Antwoord 14

Ik heb wat onderzoek gedaan naar verschillende bereikfuncties.
Bekijk de jsperf-vergelijkingvan de verschillende manieren om deze functies uit te voeren. Zeker geen perfecte of uitputtende lijst, maar zou moeten helpen 🙂

De winnaar is…

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

Technisch gezien is het niet de snelste op Firefox, maar het gekke snelheidsverschil (imho) op Chrome maakt het goed.

Ook interessante observatie is hoeveel sneller Chrome is met deze arrayfuncties dan Firefox. Chrome is minstens 4 of 5 keer sneller.

Antwoord 15

Dit is misschien niet de beste manier. Maar als u op zoek bent naar een reeks getallen in een enkele regel code. Bijvoorbeeld 10 – 50

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

Waarbij 40 is (eind – start) en 10 is het begin. Dit zou [10, 11, …, 50]

. moeten opleveren

Antwoord 16

Het standaard Javascript heeft geen ingebouwde functie om bereiken te genereren. Verschillende javascript-frameworks voegen ondersteuning toe voor dergelijke functies, of zoals anderen al hebben opgemerkt, kunt u altijd uw eigen framework gebruiken.

Als u wilt controleren, is de definitieve resource de ECMA-262 standaard .

17

range(start,end,step): met ES6-iterators

U vraagt ​​alleen om een ​​boven- en ondergrenzen. Hier maken we er ook een met een stap.

U kunt eenvoudig range()generatorfunctie maken die kan functioneren als een iterator. Dit betekent dat u niet de volledige array hoeft te genereren.

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

Misschien wilt u mogelijk iets maken dat de array van de iterator genereert en een lijst retourneert. Dit is handig voor functies die een array accepteren. Hiervoor kunnen we Array.from()

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

Nu kunt u eenvoudig een statische array genereren,

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

Maar wanneer iets een iterator wenst (of u de optie geeft om een ​​iterator te gebruiken) kunt u eenvoudig er een maken.

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

Speciale noten

• Als je Ramda gebruikt, hebben ze hun eigen R.rangenet als Lodash

Antwoord 18

Mijn persoonlijke favoriet:

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

Antwoord 19

Een interessante uitdaging zou zijn om hiervoor de functie kortstete schrijven. Recursie om te redden!

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

Heeft de neiging traag te zijn op grote afstanden, maar gelukkig zijn er kwantumcomputers om de hoek.

Een toegevoegde bonus is dat het verduisterend is. Omdat we allemaal weten hoe belangrijk het is om onze code te verbergen voor nieuwsgierige blikken.

Doe dit om de functie echt en volledig te verdoezelen:

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

Antwoord 20

Ik zou zoiets als dit coderen:

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]

Het gedraagt zich op dezelfde manier als het Python-bereik:

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

Antwoord 21

Een nogal minimalistische implementatie die veel gebruik maakt van ES6 kan als volgt worden gemaakt, met bijzondere aandacht voor de Array.from()statische methode:

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

Antwoord 22

Hoewel dit niet van PHPis, maar een imitatie van rangevan 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] 

Antwoord 23

Deze werkt ook omgekeerd.

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 ]

Antwoord 24

Voor zover ik een numerieke array voor een bepaald bereik genereer, gebruik ik dit:

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]

Het werkt duidelijk niet voor alfabetische arrays.

Antwoord 25

Je kunt de volgende one-liner gebruiken om het kort en simpel te houden

var start = 4;
var end = 20;
console.log(Array(end - start + 1).fill(start).map((x, y) => x + y));

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

range(2, 100);
function range(start, end) {
    console.log([...Array(end + 1).keys()].filter(value => end >= value && start <= value ));
}

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

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