JavaScript에 제공된 범위 내에서 범위를 생성하는 "range ()"와 같은 메서드가 있습니까?

JavaScript에 제공된 범위 내에서 범위를 생성하는 "range ()"와 같은 메서드가 있습니까?

---

PHP에서는 다음을 수행 할 수 있습니다.

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

즉, 상한과 하한을 넘김으로써 숫자 나 문자의 범위를 얻을 수있는 함수가 있습니다.

이를 위해 기본적으로 JavaScript에 내장 된 것이 있습니까? 그렇지 않다면 어떻게 구현합니까?

---

번호

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

문자 반복

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

되풀이

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"

기능으로

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

형식화 된 함수

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()함수

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

라이브러리가없는 이전 비 es6 브라우저 :

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

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

감사.

(nils petersohn 및 기타 댓글 작성자에 대한 ES6 크레딧)

---

번호는 당신이 ES6 사용할 수 있습니다 Array.from(), 요즘 모든 작동 IE를 제외한를 :

더 짧은 버전 :

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

더 긴 버전 :

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

0에서 19까지의 배열을 만듭니다. 이것은 다음 형식 중 하나로 더 짧게 할 수 있습니다.

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

하한 및 상한도 지정할 수 있습니다. 예를 들면 다음과 같습니다.

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

이에 대해 자세히 설명하는 기사 : http://www.2ality.com/2014/05/es6-array-methods.html

---

내가 가장 좋아하는 양식 ( ES2015 )

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

그리고 step매개 변수 가있는 함수가 필요한 경우 :

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

---

여기 내 2 센트입니다.

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

---

선택적 단계로 앞뒤로 이동하는 문자 및 숫자에 대해 작동합니다.

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 .

네이티브 유형을 늘리는 것이 필요한 경우 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));

---

간단한 범위 기능 :

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

---

자, JavaScript에는 PHPrange() 와 같은 함수 가 없으므로 아주 쉬운 함수를 만들어야합니다. 한 줄 함수를 몇 개 작성 하고 아래와 같이 숫자 와 알파벳 으로 구분합니다.

에 대한 번호 :

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

다음과 같이 부릅니다.

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

대한 알파벳 :

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

다음과 같이 부릅니다.

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

---

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

---

트릭을 수행하는 편리한 기능, 아래 코드 스 니펫 실행

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

사용 방법은 다음과 같습니다.

범위 (시작, 끝, 단계 = 1, 오프셋 = 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 themselves
• 오프셋-확장 range(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]

유용하다고 생각하십시오.

---

그리고 이것이 작동하는 방법입니다.

기본적으로 나는 먼저 결과 배열의 길이를 계산하고 그 길이에 0으로 채워진 배열을 만든 다음 필요한 값으로 채 웁니다.

• (step || 1)=> 그리고 이와 같은 다른 사람들은 값을 사용하고 step제공되지 않은 경우 1대신 사용을 의미 합니다.
• (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1)더 간단하게하기 위해 사용하여 결과 배열의 길이를 계산하는 것으로 시작합니다 (두 방향 / 단계에서 차이 * 오프셋).
• 길이를 얻은 후 여기에서 확인을 사용하여 초기화 된 값으로 빈 배열을 만듭니다.new Array(length).fill(0);
• 이제 [0,0,0,..]원하는 길이 의 배열 이 있습니다. 이를 매핑하고 다음을 사용하여 필요한 값으로 새 배열을 반환합니다.Array.map(function() {})
• var direction = start < end ? 1 : 0;분명히 우리가 뒤로 이동해야하는 start것보다 작지 않다면 end. 0에서 5로 또는 그 반대로
• 반복 할 때마다 startingPoint+ stepSize* index는 필요한 값을 제공합니다.

---

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

---

하모니 확산 연산자 및 화살표 기능 사용 :

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

예:

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

---

표준 자바 스크립트에는 범위를 생성하는 내장 함수가 없습니다. 몇몇 자바 스크립트 프레임 워크는 이러한 기능에 대한 지원을 추가하거나 다른 사람들이 지적했듯이 언제든지 직접 롤링 할 수 있습니다.

다시 확인하고 싶은 경우 최종 리소스는 ECMA-262 Standard 입니다.

---

다양한 범위 함수에 대해 조사했습니다. 이러한 기능을 수행하는 다양한 방법에 대한 jsperf 비교 를 확인하십시오. 확실히 완벽하거나 완전한 목록은 아니지만 도움이 될 것입니다 :)

우승자는 ...

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

기술적으로는 파이어 폭스에서 가장 빠르지는 않지만 크롬의 미친 속도 차이 (imho)가이를 보완합니다.

또한 흥미로운 관찰은 파이어 폭스보다 이러한 배열 함수로 크롬이 얼마나 빠른지입니다. Chrome은 4 ~ 5 배 이상 빠릅니다 .

---

lodash 또는 Undescore.js를 사용할 수 있습니다 range.

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

---

또는 연속 된 정수 범위 만 필요한 경우 다음과 같이 할 수 있습니다.

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

---

ES6에서는 생성기range 로 구현할 수 있습니다 .

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

이 구현은 모든 값을 배열로 구체화 할 필요가 없기 때문에 큰 시퀀스를 반복 할 때 메모리를 절약합니다.

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

---

ES6 생성기를 사용하는 다른 버전 (ES6 생성기에 대한 훌륭한 Paolo Moretti 답변 참조 ) :

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

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

또는 iterable 만 필요한 경우 :

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

for (let n of RANGE_ITER(3,7)){
  console.log(n);
}

// 3
// 4
// 5
// 6
// 7

---

흥미로운 도전은 이것을하기 위해 가장 짧은 함수를 작성하는 것 입니다. 구출에 대한 재귀!

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

넓은 범위에서 느린 경향이 있지만 운 좋게도 양자 컴퓨터는 곧 모퉁이에 있습니다.

추가 보너스는 그것이 모호하다는 것입니다. 우리 모두는 우리의 코드를 엿보는 눈에서 숨기는 것이 얼마나 중요한지 알고 있기 때문입니다.

함수를 완전히 난독 화하려면 다음과 같이하십시오.

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

---

다음과 같이 코딩합니다.

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]

Python 범위와 유사하게 작동합니다.

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

---

ES6를 많이 사용하는 다소 최소한의 구현은 다음과 같이 만들 수 있으며 Array.from()정적 메서드에 특히주의를 기울입니다 .

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

---

이것은 PHP 에서 온 것이 아니라 파이썬range 에서 모방 한 것입니다 .

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] 

---

range(start,end,step): ES6 반복자 사용

상한 및 하한 만 요구합니다. 여기에서 우리는 단계로 하나를 만듭니다.

range()반복자로 작동 할 수있는 생성기 함수를 쉽게 만들 수 있습니다 . 즉, 전체 어레이를 미리 생성 할 필요가 없습니다.

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

이제 반복기에서 배열을 미리 생성하고 목록을 반환하는 무언가를 만들 수 있습니다. 이것은 배열을받는 함수에 유용합니다. 이를 위해 우리는Array.from()

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

이제 정적 배열을 쉽게 생성 할 수 있습니다.

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

그러나 무언가가 반복자를 원할 때 (또는 반복기를 사용할 수있는 옵션을 제공) 쉽게 만들 수 있습니다.

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

특별 참고 사항

• RamdaR.range 를 사용하는 경우 Lodash 처럼 고유 한 기능이 있습니다.

---

주어진 범위에 대해 숫자 배열을 생성하는 한 다음을 사용합니다.

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]

분명히 알파벳 배열에서는 작동하지 않습니다.

---

IE11을 제외한 모든 브라우저 에서 지원되는 Harmony 생성기 사용 :

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

예

갖다

예 1.

take 얻을 수있는만큼만 걸립니다

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

보고

[100, 105, 110, 115, 120]

예 2.

to 필요하지 않다

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

보고

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

모두 가져가

예 3.

from 필요하지 않다

takeAll( range( {to: 5} ) )

보고

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

예 4.

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

보고

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

예 5.

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

보고

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

---

... 더 많은 범위, 생성기 기능 사용.

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.

이것이 유용하기를 바랍니다.

---

https://lodash.com/docs#rangelodash 기능 을 사용할 수 있습니다._.range(10)

---

d3에는 또한 내장 범위 기능이 있습니다. 참조 https://github.com/mbostock/d3/wiki/Arrays#d3_range를 :

d3.range ([시작,] 중지 [, 단계])

Python 내장 범위와 유사한 산술 진행을 포함하는 배열을 생성합니다. 이 메서드는 배열에 대한 인덱스와 같은 일련의 숫자 또는 정수 값을 반복하는 데 자주 사용됩니다. Python 버전과 달리 인수가 정수일 필요는 없지만 부동 소수점 정밀도로 인해 결과가 더 예측 가능합니다. 단계를 생략하면 기본값은 1입니다.

예:

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

---

range ([start,] stop [, step]) 서명을 사용하여 ES6 구현 완료 :

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(stop<start)step=-Math.abs(step)

또는 더 최소한 :

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

범위가 넓은 경우 Paolo Moretti의 생성기 접근 방식을 살펴보십시오.

---

이를 위한 npm 모듈 bereich 가 있습니다 ( "bereich"는 "range"에 대한 독일어 단어입니다). 최신 JavaScript의 반복자를 사용하므로 다음과 같은 다양한 방법으로 사용할 수 있습니다.

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

또한 내림차순 범위 ( min및을 교환 하여 max)를 지원하고 1.

면책 조항 : 저는이 모듈의 작성자이므로 제 답변을 조금만 이해해주십시오.

---

이것은 최선의 방법이 아닐 수 있습니다. 그러나 한 줄의 코드에서 다양한 숫자를 얻으려는 경우. 예 : 10-50

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

여기서 40은 (끝-시작)이고 10은 시작입니다. [10, 11, ..., 50]을 반환해야합니다 .

---

나는이 스레드를 발견하고 내 솔루션과 같은 것을 보지 못하는 것에 놀랐습니다 (아마도 대답을 놓쳤을 수도 있습니다), 여기 있습니다. ES6 구문에서 간단한 범위 함수를 사용합니다.

// [begin, end[
const range = (b, e) => Array.apply(null, Array(e - b)).map((_, i) => {return i+b;});

하지만 앞으로 세어 볼 때만 작동하므로 (즉, begin <end) 필요할 때 다음과 같이 약간 수정할 수 있습니다.

const range = (b, e) => Array.apply(null, Array(Math.abs(e - b))).map((_, i) => {return b < e ? i+b : b-i;});

---

다음은 ES6에서 숫자로만 수행 할 수있는 좋은 짧은 방법입니다 (속도 비교를 알 수 없음).

Array.prototype.map.call(' '.repeat(1 + upper - lower), (v, i) => i + lower)

단일 문자 범위의 경우 약간 수정할 수 있습니다.

Array.prototype.map.call(' '.repeat(1 + upper.codePointAt() - lower.codePointAt()), (v, i) => String.fromCodePoint(i + lower.codePointAt()));

참고 URL : https://stackoverflow.com/questions/3895478/does-javascript-have-a-method-like-range-to-generate-a-range-within-the-supp