En PHP, puedes hacer ...

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

Es decir, hay una función que le permite obtener un rango de números o caracteres al pasar los límites superior e inferior.

¿Hay algo incorporado en JavaScript de forma nativa para esto? Si no, ¿cómo lo implementaría?

Números

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

Iteración de personajes

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

Iteración

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"

Como funciones

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

Como funciones escritas

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()función 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"

Navegadores antiguos que no son es6 sin una biblioteca:

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

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

(Crédito ES6 a nils petersohn y otros comentaristas)

Para los números, puede usar ES6 Array.from(), que funciona en todo en estos días excepto IE:

Versión más corta:

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

Versión más larga:

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

que crea una matriz de 0 a 19 inclusive. Esto se puede acortar aún más a una de estas formas:

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

Los límites inferior y superior también se pueden especificar, por ejemplo:

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

Un artículo que describe esto con más detalle: http://www.2ality.com/2014/05/es6-array-methods.html

Mi nueva forma favorita ( ES2015 )

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

Y si necesita una función con un stepparámetro:

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

Aquí están mis 2 centavos:

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

Funciona para caracteres y números, avanzando o retrocediendo con un paso opcional.

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 lo suyo es aumentar los tipos nativos, asígnelo 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));

Función de rango simple:

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

Para incorporar el tipo de datos BitInt, se puede incluir alguna verificación, asegurando que todas las variables sean iguales 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;
}

Para eliminar valores superiores a los definidos por stopejemplo range(0,5,2), incluirá 6, que no debería ser.

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 no tenemos una range()función como PHP , por lo que necesitamos crear la función, lo cual es bastante fácil, escribo un par de funciones de una línea para usted y las separo para Números y Alfabetos de la siguiente manera:

para los números :

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

y lo llaman así:

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

para alfabetos :

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

y lo llaman así:

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

Función práctica para hacer el truco, ejecuta el fragmento de código a continuación

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

aquí es cómo usarlo

rango (inicio, fin, paso = 1, desplazamiento = 0);

• inclusivo - adelante range(5,10) // [5, 6, 7, 8, 9, 10]
• inclusivo - hacia atrás range(10,5) // [10, 9, 8, 7, 6, 5]
• paso atrás range(10,2,2) // [10, 8, 6, 4, 2]
• exclusivo - adelante range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• desplazamiento - expandir range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• offset - reducir range(5,10,0,-2) // [7, 8]
• paso - expandir range(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]

Esperamos que te sea útil.

Y así es como funciona.

Básicamente, primero estoy calculando la longitud de la matriz resultante y creo una matriz llena de cero a esa longitud, luego la lleno con los valores necesarios

• (step || 1)=> Y otros como este medio utilizan el valor de stepy si no se proporciona el uso 1en vez
• Comenzamos calculando la longitud de la matriz de resultados usando (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1)para simplificarla (diferencia * desplazamiento en ambas direcciones / pasos)
• Después de obtener la longitud, creamos una matriz vacía con valores inicializados usando new Array(length).fill(0); marcar aquí
• Ahora tenemos una matriz [0,0,0,..]a la longitud que queremos. Lo mapeamos y devolvemos una nueva matriz con los valores que necesitamos usandoArray.map(function() {})
• var direction = start < end ? 1 : 0;Obviamente si startno es más pequeño que el endnecesitamos retroceder. Me refiero a ir de 0 a 5 o viceversa
• En cada iteración, startingPoint+ stepSize* indexnos dará el valor que necesitamos

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

Usando el operador de expansión Harmony y las funciones de flecha:

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

Ejemplo:

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

--- ACTUALIZACIÓN (Gracias a @lokhmakov por la simplificación) ---

Otra versión que usa generadores ES6 (vea la excelente respuesta de Paolo Moretti con generadores ES6 ):

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

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

O, si solo necesitamos iterables, entonces:

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

--- El código ORIGINAL fue: ---

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

y

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

Investigué un poco sobre algunas funciones de rango. Consulte la comparación jsperf de las diferentes formas de realizar estas funciones. Ciertamente no es una lista perfecta o exhaustiva, pero debería ayudar :)

El ganador es...

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

Técnicamente no es el más rápido en Firefox, pero la diferencia de velocidad loca (IMHO) en Chrome lo compensa.

También es interesante observar cuánto más rápido es Chrome con estas funciones de matriz que Firefox. Chrome es al menos 4 o 5 veces más rápido .

El Javascript estándar no tiene una función incorporada para generar rangos. Varios marcos de JavaScript agregan soporte para tales características, o como otros han señalado, siempre puede implementar el suyo.

Si desea verificar dos veces, el recurso definitivo es el estándar ECMA-262 .

Puede usar lodash o Undescore.js range :

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

Alternativamente, si solo necesita un rango consecutivo de enteros, puede hacer algo como:

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

En ES6 rangese puede implementar con generadores :

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

Esta implementación ahorra memoria al iterar secuencias grandes, porque no tiene que materializar todos los valores en una matriz:

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

Un desafío interesante sería escribir la función más corta para hacer esto. ¡Recursión al rescate!

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

Tiende a ser lento en grandes rangos, pero afortunadamente las computadoras cuánticas están a la vuelta de la esquina.

Una ventaja adicional es que es ofuscatorio. Porque todos sabemos lo importante que es ocultar nuestro código de miradas indiscretas.

Para ofuscar verdadera y completamente la función, haga esto:

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

Esta puede no ser la mejor manera. Pero si está buscando obtener un rango de números en una sola línea de código. Por ejemplo 10 - 50

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

Donde 40 es (fin - inicio) y 10 es el comienzo. Esto debería devolver [10, 11, ..., 50]

Codificaría algo como esto:

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]

Se comporta de manera similar al rango de Python:

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

Una implementación bastante minimalista que emplea ES6 en gran medida se puede crear de la siguiente manera, llamando especialmente la atención sobre el Array.from()método estático:

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

range(start,end,step): Con iteradores ES6

Solo solicita un límite superior e inferior. Aquí creamos uno con un paso también.

Puede crear fácilmente la range()función de generador que puede funcionar como un iterador. Esto significa que no tiene que generar previamente toda la matriz.

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

Ahora es posible que desee crear algo que genere previamente la matriz desde el iterador y devuelva una lista. Esto es útil para funciones que aceptan una matriz. Para esto podemos usarArray.from()

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

Ahora puede generar una matriz estática fácilmente,

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

Pero cuando algo desea un iterador (o le da la opción de usar un iterador), también puede crear uno fácilmente.

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

Notas especiales

• Si usas Ramda, ellos tienen los suyos, alR.range igual que Lodash

Aunque esto no es de PHP , pero una imitación de la 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 cuanto a generar una matriz numérica para un rango dado, uso esto:

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]

Obviamente, no funcionará para matrices alfabéticas.

Uso de generadores Harmony , compatibles con todos los navegadores, excepto 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;
        }
    }
});

Ejemplos

tomar

Ejemplo 1.

take solo toma la mayor cantidad posible

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

devoluciones

[100, 105, 110, 115, 120]

Ejemplo 2

to no necesario

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

devoluciones

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

tomalo todo

Ejemplo 3

from no necesario

takeAll( range( {to: 5} ) )

devoluciones

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

Ejemplo 4

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

devoluciones

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

Ejemplo 5

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

devoluciones

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

... más rango, usando una función de generador.

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.

Espero que esto sea útil.

A mi compañero de codegolfing se le ocurrió esto (ES6), incluido:

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

no inclusivo:

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

puedes usar la lodashfunción _.range(10) https://lodash.com/docs#range

d3 también tiene una función de rango incorporada. Ver https://github.com/mbostock/d3/wiki/Arrays#d3_range :

d3.range ([inicio,] parada [, paso])

Genera una matriz que contiene una progresión aritmética, similar al rango incorporado de Python. Este método a menudo se usa para iterar sobre una secuencia de valores numéricos o enteros, como los índices en una matriz. A diferencia de la versión de Python, no es necesario que los argumentos sean enteros, aunque los resultados son más predecibles si se deben a la precisión de coma flotante. Si se omite el paso, el valor predeterminado es 1.

Ejemplo:

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

Complete la implementación de ES6 usando la firma de rango ([inicio,] parada [, paso]):

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 desea pasos negativos automáticos, agregue

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

O más minimalistamente:

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 tienes grandes rangos, mira el enfoque del generador de Paolo Moretti

Hay un módulo npm bereich para eso ("bereich" es la palabra alemana para "rango"). Utiliza los iteradores modernos de JavaScript, por lo que puede usarlo de varias maneras, como:

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

También admite rangos descendentes (simplemente intercambiando miny max), y también admite pasos distintos a 1.

Descargo de responsabilidad: soy el autor de este módulo, así que tome mi respuesta con un grano de sal.

Este también funciona a la inversa.

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 ]