En PHP, vous pouvez faire ...

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

Autrement dit, il existe une fonction qui vous permet d'obtenir une plage de chiffres ou de caractères en passant les limites supérieure et inférieure.

Y a-t-il quelque chose de natif intégré à JavaScript pour cela? Sinon, comment pourrais-je le mettre en œuvre?

Nombres

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

Itération de caractère

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

Itération

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"

Comme fonctions

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

En tant que fonctions tapées

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

_.range()Fonction lodash.js

_.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"

Anciens navigateurs non es6 sans bibliothèque:

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

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

(Crédit ES6 à Nils Petersohn et à d'autres commentateurs)

Pour les nombres, vous pouvez utiliser ES6 Array.from(), qui fonctionne dans tout, de nos jours, sauf IE:

Version plus courte:

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

Version plus longue:

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

ce qui crée un tableau de 0 à 19 inclus. Cela peut être encore raccourci à l'une de ces formes:

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

Des limites inférieures et supérieures peuvent également être spécifiées, par exemple:

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

Un article décrivant cela plus en détail: http://www.2ality.com/2014/05/es6-array-methods.html

Ma nouvelle forme préférée ( ES2015 )

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

Et si vous avez besoin d'une fonction avec un stepparamètre:

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

Voici mes 2 cents:

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

Il fonctionne pour les caractères et les chiffres, en avant ou en arrière avec une étape facultative.

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 .

Si vous préférez augmenter les types natifs, affectez-le à 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));

Fonction de portée simple:

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

Pour incorporer le type de données BitInt, une vérification peut être incluse, garantissant que toutes les variables sont identiques 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;
}

Pour supprimer des valeurs supérieures à celles définies par stopexemple range(0,5,2), inclura 6, qui ne devrait pas l'être.

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

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']

OK, en JavaScript, nous n'avons pas de range()fonction comme PHP , nous devons donc créer la fonction qui est assez simple, j'écris quelques fonctions d'une ligne pour vous et je les sépare pour les nombres et les alphabets comme ci-dessous:

pour les nombres :

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

et appelez-le comme:

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

pour les alphabets :

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

et appelez-le comme:

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

Handy fonction pour faire le tour, exécutez l'extrait de code ci - dessous

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

voici comment l'utiliser

plage (début, fin, étape = 1, décalage = 0);

• inclus - avant range(5,10) // [5, 6, 7, 8, 9, 10]
• inclus - en arrière range(10,5) // [10, 9, 8, 7, 6, 5]
• reculer range(10,2,2) // [10, 8, 6, 4, 2]
• exclusif - avant range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• décalage - étendre range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• offset - rétrécir range(5,10,0,-2) // [7, 8]
• étape - élargir range(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]

j'espère que vous le trouverez utile.

Et voici comment cela fonctionne.

Fondamentalement, je calcule d'abord la longueur du tableau résultant et crée un tableau rempli de zéro à cette longueur, puis le remplit avec les valeurs nécessaires

• (step || 1)=> Et d'autres comme cela signifie utiliser la valeur de stepet si elle n'a pas été fournie, utiliser à la 1place
• Nous commençons par calculer la longueur du tableau de résultats en utilisant (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1)pour le simplifier (différence * décalage dans les deux sens / pas)
• Après avoir obtenu la longueur, nous créons un tableau vide avec des valeurs initialisées en utilisant la new Array(length).fill(0); vérification ici
• Maintenant, nous avons un tableau [0,0,0,..]à la longueur souhaitée. Nous mappons dessus et retournons un nouveau tableau avec les valeurs dont nous avons besoin en utilisantArray.map(function() {})
• var direction = start < end ? 1 : 0;Évidemment, si ce startn'est pas plus petit que le, endnous devons reculer. Je veux dire passer de 0 à 5 ou vice versa
• À chaque itération, startingPoint+ stepSize* indexwill nous donne la valeur dont nous avons besoin

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

Utilisation des fonctions d' opérateur et de flèche Harmony :

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

Exemple:

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

--- MISE À JOUR (Merci à @lokhmakov pour la simplification) ---

Une autre version utilisant des générateurs ES6 (voir la bonne réponse de Paolo Moretti avec les générateurs ES6 ):

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

console.log(RANGE(3,7));  // [ 3, 4, 5, 6, 7 ]

Ou, si nous avons seulement besoin d'itérable, alors:

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

--- Le code ORGINAL était: ---

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

et

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

A fait des recherches sur différentes fonctions de plage. Découvrez la comparaison jsperf des différentes façons de faire ces fonctions. Certainement pas une liste parfaite ou exhaustive, mais devrait aider :)

Le gagnant est...

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

Techniquement, ce n'est pas le plus rapide sur Firefox, mais une différence de vitesse folle (à mon humble avis) sur Chrome le compense.

Une observation également intéressante est à quel point le chrome est plus rapide avec ces fonctions de tableau que Firefox. Chrome est au moins 4 ou 5 fois plus rapide .

Le Javascript standard n'a pas de fonction intégrée pour générer des plages. Plusieurs frameworks javascript ajoutent la prise en charge de telles fonctionnalités, ou comme d'autres l'ont souligné, vous pouvez toujours lancer la vôtre.

Si vous souhaitez revérifier, la ressource définitive est la norme ECMA-262 .

Vous pouvez utiliser lodash ou Undescore.js range :

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

Alternativement, si vous n'avez besoin que d'une plage consécutive d'entiers, vous pouvez faire quelque chose comme:

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

Dans ES6 rangepeut être implémenté avec des générateurs :

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

Cette implémentation économise de la mémoire lors de l'itération de grandes séquences, car elle n'a pas à matérialiser toutes les valeurs dans un tableau:

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

Un défi intéressant serait d'écrire la fonction la plus courte pour ce faire. Récursivité à la rescousse!

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

A tendance à être lent sur de grandes plages, mais heureusement, les ordinateurs quantiques sont juste autour du coin.

Un bonus supplémentaire est qu'il est obscur. Parce que nous savons tous combien il est important de cacher notre code aux regards indiscrets.

Pour vraiment et complètement obscurcir la fonction, procédez comme suit:

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

Ce n'est peut-être pas la meilleure façon. Mais si vous cherchez à obtenir une plage de chiffres sur une seule ligne de code. Par exemple 10 - 50

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

Où 40 est (fin - début) et 10 est le début. Cela devrait retourner [10, 11, ..., 50]

Je coderais quelque chose comme ceci:

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]

Il se comporte de manière similaire à la gamme Python:

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

Une implémentation plutôt minimaliste qui utilise fortement ES6 peut être créée comme suit, en attirant une attention particulière sur la Array.from()méthode statique:

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

range(start,end,step): Avec les itérateurs ES6

Vous ne demandez que des limites supérieures et inférieures. Ici, nous en créons un avec une étape aussi.

Vous pouvez facilement créer une range()fonction de générateur qui peut fonctionner comme un itérateur. Cela signifie que vous n'avez pas à pré-générer l'intégralité du tableau.

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

Vous pouvez maintenant créer quelque chose qui pré-génère le tableau à partir de l'itérateur et renvoie une liste. Ceci est utile pour les fonctions qui acceptent un tableau. Pour cela, nous pouvons utiliserArray.from()

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

Vous pouvez maintenant générer facilement un tableau statique,

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

Mais lorsque quelque chose désire un itérateur (ou vous donne la possibilité d'utiliser un itérateur), vous pouvez facilement en créer un aussi.

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

Notes spéciales

• Si vous utilisez Ramda, ils ont le leur, toutR.range comme Lodash

Bien que ce n'est pas de PHP , mais une imitation de rangede 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] 

En ce qui concerne la génération d'un tableau numérique pour une plage donnée, j'utilise ceci:

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]

De toute évidence, cela ne fonctionnera pas pour les tableaux alphabétiques.

Utilisation de générateurs Harmony , pris en charge par tous les navigateurs à l'exception d'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;
        }
    }
});

Exemples

prendre

Exemple 1.

take prend seulement autant que possible

take(10, range( {from: 100, step: 5, to: 120} ) )

Retour

[100, 105, 110, 115, 120]

Exemple 2.

to pas nécessaire

take(10, range( {from: 100, step: 5} ) )

Retour

[100, 105, 110, 115, 120, 125, 130, 135, 140, 145]

prendre toutes

Exemple 3.

from pas nécessaire

takeAll( range( {to: 5} ) )

Retour

[0, 1, 2, 3, 4, 5]

Exemple 4.

takeAll( range( {to: 500, step: 100} ) )

Retour

[0, 100, 200, 300, 400, 500]

Exemple 5.

takeAll( range( {from: 'z', to: 'a'} ) )

Retour

["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"]

... plus de portée grâce à une fonction générateur.

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.

J'espère que c'est utile.

Mon collègue de golf de code est venu avec ceci (ES6), inclus:

(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)

non inclus:

(s,f)=>[...Array(f-s)].map((e,i)=>i+s)

vous pouvez utiliser la lodashfonction _.range(10) https://lodash.com/docs#range

d3 a également une fonction de gamme intégrée. Voir https://github.com/mbostock/d3/wiki/Arrays#d3_range :

d3.range ([démarrer,] arrêter [, étape])

Génère un tableau contenant une progression arithmétique, similaire à la plage intégrée Python. Cette méthode est souvent utilisée pour itérer sur une séquence de valeurs numériques ou entières, telles que les index dans un tableau. Contrairement à la version Python, les arguments ne doivent pas nécessairement être des entiers, bien que les résultats soient plus prévisibles s'ils sont dus à la précision en virgule flottante. Si l'étape est omise, elle vaut par défaut 1.

Exemple:

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

Implémentation complète d'ES6 en utilisant la signature de la plage ([start,] stop [, step]):

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

Si vous voulez un pas négatif automatique, ajoutez

if(stop<start)step=-Math.abs(step)

Ou plus minimaliste:

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

Si vous avez d'énormes gammes, regardez l'approche du générateur de Paolo Moretti

Il y a un module npm bereich pour cela ("bereich" est le mot allemand pour "range"). Il utilise les itérateurs modernes de JavaScript, vous pouvez donc l'utiliser de différentes manières, telles que:

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)) {
  // ...
}

Il prend également en charge les plages décroissantes (en échangeant simplement minet max), et prend également en charge les étapes autres que 1.

Avertissement: je suis l'auteur de ce module, veuillez donc prendre ma réponse avec un grain de sel.

Celui-ci fonctionne également à l'envers.

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 ]