Em PHP, você pode fazer ...

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

Ou seja, existe uma função que permite obter um intervalo de números ou caracteres passando os limites superior e inferior.

Existe algo embutido no JavaScript nativamente para isso? Caso contrário, como eu o implementaria?

Números

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

Iteração de caracteres

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

Iteração

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 funções

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 funções digitadas

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()função 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 antigos não es6 sem uma 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 e outros comentadores)

Para números, você pode usar o ES6 Array.from(), que funciona em tudo hoje em dia, exceto no IE:

Versão mais curta:

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

Versão mais longa:

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

que cria uma matriz de 0 a 19 inclusive. Isso pode ser reduzido ainda mais para uma destas formas:

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

Os limites inferior e superior também podem ser especificados, por exemplo:

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

Um artigo que descreve isso com mais detalhes: http://www.2ality.com/2014/05/es6-array-methods.html

Meu novo formulário favorito ( ES2015 )

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

E se você precisar de uma função com um stepparâmetro:

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

Aqui estão os meus 2 centavos:

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

Funciona para caracteres e números, avançando ou retrocedendo com uma etapa 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 .

Se você gosta de aumentar tipos nativos, atribua-o a 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));

Função de faixa simples:

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

Para incorporar o tipo de dados BitInt, algumas verificações podem ser incluídas, garantindo que todas as variáveis ​​sejam iguais 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;
}

Remover valores mais altos do que os definidos por stopexemplo range(0,5,2)incluirá 6, o que não deveria 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, em JavaScript, não temos uma range()função como PHP , por isso precisamos criar a função que é bastante fácil, escrevo algumas funções de uma linha para você e as separo para Numbers e Alphabets, como abaixo:

para números :

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

e chame assim:

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

e chame assim:

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

Função útil para executar o truque, execute o trecho de código abaixo

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

aqui está como usá-lo

range (Início, Fim, Passo = 1, Deslocamento = 0);

• inclusivo - encaminhar range(5,10) // [5, 6, 7, 8, 9, 10]
• inclusivo - para trás range(10,5) // [10, 9, 8, 7, 6, 5]
• Um passo atrás range(10,2,2) // [10, 8, 6, 4, 2]
• exclusivo - encaminhar range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• deslocamento - expandir range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• offset - encolher range(5,10,0,-2) // [7, 8]
• passo - expandir range(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]

espero que você ache útil.

E aqui está como isso funciona.

Basicamente, estou primeiro calculando o comprimento da matriz resultante e criando uma matriz preenchida com zero nesse comprimento, depois preenchendo-a com os valores necessários

• (step || 1)=> E outros como este meio usar o valor do stepe se não foi fornecido o uso 1em vez
• Começamos calculando o comprimento da matriz de resultados usando-a (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1)para simplificar (diferença * deslocamento na direção / etapa)
• Depois de obter o comprimento, criamos uma matriz vazia com valores inicializados usando new Array(length).fill(0); check aqui
• Agora temos uma matriz [0,0,0,..]com o comprimento que queremos. Mapeamos sobre ele e retornamos uma nova matriz com os valores que precisamos usandoArray.map(function() {})
• var direction = start < end ? 1 : 0;Obviamente, se startnão for menor do que o endnecessário, precisamos retroceder. Quero dizer, passando de 0 a 5 ou vice-versa
• Em cada iteração, startingPoint+ stepSize* indexwill nos fornece o valor que precisamos

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

Usando o operador de propagação Harmony e as funções de seta:

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

Exemplo:

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

--- ATUALIZAÇÃO (Agradecimentos a @lokhmakov pela simplificação) ---

Outra versão usando geradores ES6 (veja a excelente resposta de Paolo Moretti com geradores ES6 ):

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

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

Ou, se precisarmos apenas de iterável, então:

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

--- O código original era: ---

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

e

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

Fiz algumas pesquisas sobre várias funções de intervalo. Confira a comparação do jsperf das diferentes maneiras de executar essas funções. Certamente não é uma lista perfeita ou exaustiva, mas deve ajudar :)

O vencedor é...

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

Tecnicamente, não é o mais rápido no Firefox, mas a louca diferença de velocidade (imho) no Chrome compensa isso.

Também é interessante observar o quão rápido o cromo é com essas funções de matriz do que o firefox. O Chrome é pelo menos 4 ou 5 vezes mais rápido .

O Javascript padrão não possui uma função interna para gerar intervalos. Várias estruturas javascript adicionam suporte para esses recursos ou, como outros já apontaram, você sempre pode criar seus próprios.

Se você deseja verificar novamente, o recurso definitivo é o padrão ECMA-262 .

Você pode usar lodash ou Undescore.js range :

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

Como alternativa, se você precisar apenas de um intervalo consecutivo de números inteiros, poderá fazer algo como:

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

No ES6 rangepode ser implementado com geradores :

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

Essa implementação economiza memória ao iterar grandes seqüências, porque não precisa materializar todos os valores em uma matriz:

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

Um desafio interessante seria escrever a função mais curta para fazer isso. Recursão ao resgate!

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

Tende a ser lento em grandes faixas, mas felizmente os computadores quânticos estão ao virar da esquina.

Um bônus adicional é que é ofuscante. Porque todos sabemos o quanto é importante ocultar nosso código de olhares indiscretos.

Para ofuscar verdadeira e totalmente a função, faça o seguinte:

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

Esta pode não ser a melhor maneira. Mas se você deseja obter um intervalo de números em uma única linha de código. Por exemplo 10 - 50

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

Onde 40 é (fim - começo) e 10 é o começo. Isso deve retornar [10, 11, ..., 50]

Eu codificaria algo como isto:

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]

Ele se comporta de maneira semelhante ao intervalo do Python:

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

Uma implementação bastante minimalista que emprega fortemente o ES6 pode ser criada da seguinte maneira, chamando atenção especial para o Array.from()método estático:

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

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

Você só pede limites superior e inferior. Aqui nós criamos um com um passo também.

Você pode criar facilmente a range()função de gerador, que pode funcionar como um iterador. Isso significa que você não precisa pré-gerar toda a matriz.

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

Agora você pode criar algo que pré-gera a matriz do iterador e retorna uma lista. Isso é útil para funções que aceitam uma matriz. Para isso, podemos usarArray.from()

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

Agora você pode gerar uma matriz estática facilmente,

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

Mas quando algo deseja um iterador (ou oferece a opção de usar um iterador), você também pode facilmente criar um.

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

Notas especiais

• Se você usa Ramda, eles têm os seus própriosR.range , assim como o Lodash

Embora isso não seja do PHP , mas uma imitação rangedo 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] 

Na medida em que gera uma matriz numérica para um determinado intervalo, eu uso o seguinte:

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, não funcionará para matrizes alfabéticas.

Usando geradores Harmony , suportados por todos os navegadores, exceto o 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;
        }
    }
});

Exemplos

toma

Exemplo 1.

take leva apenas o máximo possível

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

retorna

[100, 105, 110, 115, 120]

Exemplo 2

to não necessário

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

retorna

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

leve tudo

Exemplo 3

from não necessário

takeAll( range( {to: 5} ) )

retorna

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

Exemplo 4

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

retorna

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

Exemplo 5

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

retorna

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

... mais alcance, usando uma função de gerador.

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 isso seja útil.

Meu colega de trabalho de codegolfe veio com isso (ES6), inclusive:

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

não inclusivo:

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

você pode usar a lodashfunção _.range(10) https://lodash.com/docs#range

O d3 também possui uma função de alcance embutida. Consulte https://github.com/mbostock/d3/wiki/Arrays#d3_range :

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

Gera uma matriz que contém uma progressão aritmética, semelhante ao intervalo interno do Python. Esse método é frequentemente usado para iterar sobre uma sequência de valores numéricos ou inteiros, como os índices em uma matriz. Diferentemente da versão do Python, os argumentos não precisam ser números inteiros, embora os resultados sejam mais previsíveis se forem devido à precisão do ponto flutuante. Se a etapa for omitida, o padrão será 1.

Exemplo:

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

Implementação completa do ES6 usando a assinatura de intervalo ([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)
}

Se você quiser um passo negativo automático, adicione

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

Ou mais minimalisticamente:

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

Se você tem grandes faixas, observe a abordagem de gerador de Paolo Moretti

Existe um módulo npm bereich para isso ("bereich" é a palavra alemã para "range"). Utiliza os iteradores modernos do JavaScript, para que você possa usá-lo de várias maneiras, 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)) {
  // ...
}

Ele também suporta intervalos descendentes (simplesmente trocando mine max) e também suporta outras etapas que não 1.

Isenção de responsabilidade: eu sou o autor deste módulo; portanto, responda com um grão de sal.

Este também funciona ao contrário.

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 ]