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.lodash 함수

_.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()]);

(Nilspetersohn 및 기타 논객에 대한 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)

MDN 문서에서 제안할 수 있는 다른 구현은 다음과 같습니다.

// Sequence generator function 
// (commonly referred to as "range", e.g. Clojure, PHP etc)
const range = (start, stop, step) => 
  Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step))

여기 2센트 있습니다.

function range(start, end) {
  return Array.apply(0, Array(end - 1))
    .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;
}

---

BigInt 데이터 유형을 통합하기 위해 모든 변수가 동일한지 확인하기 위해 몇 가지 검사를 포함할 수 있습니다.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;
}

---

에서 값을 stop ★★range(0,5,2) 포함하다6그래선 안 될 일이었죠

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

좋습니다. JavaScript에는range()PHP와 같이 기능하기 때문에 매우 쉬운 함수를 만들어야 합니다.여러분들을 위해 한 줄의 함수를 몇 개 쓰고 아래와 같이 Numbers와 Alphabets로 구분합니다.

번호의 경우:

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

https://stackoverflow.com/a/49577331/8784402

델타/스텝 포함

smallest and one-liner

[...Array(N)].map((_, i) => from + i * step);

예 및 기타 대안

[...Array(10)].map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array.from(Array(10)).map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array.from(Array(10).keys()).map(i => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

[...Array(10).keys()].map(i => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

Array(10).fill(0).map((_, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array(10).fill().map((_, i) => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

Range Function

const range = (from, to, step) =>
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);

range(0, 9, 2);
//=> [0, 2, 4, 6, 8]

// can also assign range function as static method in Array class (but not recommended )
Array.range = (from, to, step) =>
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);

Array.range(2, 10, 2);
//=> [2, 4, 6, 8, 10]

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

Array.range(2, 10, -1);
//=> []

Array.range(3, 0, -1);
//=> [3, 2, 1, 0]

As Iterators

class Range {
  constructor(total = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      for (let i = 0; i < total; yield from + i++ * step) {}
    };
  }
}

[...new Range(5)]; // Five Elements
//=> [0, 1, 2, 3, 4]
[...new Range(5, 2)]; // Five Elements With Step 2
//=> [0, 2, 4, 6, 8]
[...new Range(5, -2, 10)]; // Five Elements With Step -2 From 10
//=>[10, 8, 6, 4, 2]
[...new Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of new Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

As Generators Only

const Range = function* (total = 0, step = 1, from = 0) {
  for (let i = 0; i < total; yield from + i++ * step) {}
};

Array.from(Range(5, -2, -10));
//=> [-10, -12, -14, -16, -18]

[...Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

// Lazy loaded way
const number0toInf = Range(Infinity);
number0toInf.next().value;
//=> 0
number0toInf.next().value;
//=> 1
// ...

단계/델타 포함 시작부터 종료

using iterators

class Range2 {
  constructor(to = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      let i = 0,
        length = Math.floor((to - from) / step) + 1;
      while (i < length) yield from + i++ * step;
    };
  }
}
[...new Range2(5)]; // First 5 Whole Numbers
//=> [0, 1, 2, 3, 4, 5]

[...new Range2(5, 2)]; // From 0 to 5 with step 2
//=> [0, 2, 4]

[...new Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

using Generators

const Range2 = function* (to = 0, step = 1, from = 0) {
  let i = 0,
    length = Math.floor((to - from) / step) + 1;
  while (i < length) yield from + i++ * step;
};

[...Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

let even4to10 = Range2(10, 2, 4);
even4to10.next().value;
//=> 4
even4to10.next().value;
//=> 6
even4to10.next().value;
//=> 8
even4to10.next().value;
//=> 10
even4to10.next().value;
//=> undefined

타이프 스크립트의 경우

class _Array<T> extends Array<T> {
  static range(from: number, to: number, step: number): number[] {
    return Array.from(Array(Math.floor((to - from) / step) + 1)).map(
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);

https://stackoverflow.com/a/64599169/8784402

한 줄로 캐릭터 목록 생성

const charList = (a,z,d=1)=>(a=a.charCodeAt(),z=z.charCodeAt(),[...Array(Math.floor((z-a)/d)+1)].map((_,i)=>String.fromCharCode(a+i*d)));

console.log("from A to G", charList('A', 'G'));
console.log("from A to Z with step/delta of 2", charList('A', 'Z', 2));
console.log("reverse order from Z to P", charList('Z', 'P', -1));
console.log("from 0 to 5", charList('0', '5', 1));
console.log("from 9 to 5", charList('9', '5', -1));
console.log("from 0 to 8 with step 2", charList('0', '8', 2));
console.log("from α to ω", charList('α', 'ω'));
console.log("Hindi characters from क to ह", charList('क', 'ह'));
console.log("Russian characters from А to Я", charList('А', 'Я'));

For TypeScript

const charList = (p: string, q: string, d = 1) => {
  const a = p.charCodeAt(0),
    z = q.charCodeAt(0);
  return [...Array(Math.floor((z - a) / d) + 1)].map((_, i) =>
    String.fromCharCode(a + i * d)
  );
};

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

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

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]
• - 로 - 함 - 함 - - 후 inclusiverange(10,5) // [10, 9, 8, 7, 6, 5]
• - backward - step steprange(10,2,2) // [10, 8, 6, 4, 2]
• exclusive - - exclusiverange(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• - expand " " " - " " "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는 로 하는 .

--- UPDATE (심플화를 위해 @lokhmakov 덕분에) ---

ES6 제너레이터를 사용하는 다른 버전(ES6 제너레이터를 사용한 훌륭한 Paolo Moretti 응답 참조):

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

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

또는, 만약 우리가 그것을 필요로 한다면,

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

--- ORGINAL 코드는 다음과 같습니다. ---

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

그리고.

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

조화 확산 연산자 및 화살표 기능 사용:

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

예:

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

다양한 레인지 함수에 대해 조사했습니다.이러한 기능을 수행하는 다양한 방법의 jsperf 비교를 확인하십시오.분명 완벽하거나 포괄적인 목록은 아니지만 도움이 될 것입니다.

우승자는...

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

엄밀히 말하면 파이어폭스에서는 가장 빠른 것은 아니지만 크롬에서는 엄청난 속도 차이(imho)가 이를 보완한다.

또한 이러한 어레이 기능에서 크롬이 파이어폭스보다 얼마나 빠른지도 관찰할 수 있습니다.크롬은 최소 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);
}

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

특기 사항

• Ramda를 사용하면 Lodash와 마찬가지로 그들만의 Ramda를 사용할 수 있습니다.

이게 최선의 방법이 아닐 수도 있어요.단, 코드 한 줄에 다양한 번호를 입력하고자 하는 경우.예: 10 - 50

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

여기서 40은 (end - start)이고 10은 시작입니다.[10, 11, ..., 50]이 반환됩니다.

아직 구현되지 않았습니다!

새로운 기능 사용Number.range 제안(1단계):

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

이렇게 코드화할 수 있습니다.

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]

개인적으로 좋아하는 것:

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

(from, to) => [...Array(to - from)].map((_,i)=> i + from)

Visual Studio Code에서 오류가 발생한 경우:

'ItableIterator' 유형은 배열 형식이나 문자열 형식이 아닙니다.컴파일러 옵션 '--downlevelIteration'을 사용하여 반복을 허용합니다.

대신

[...Array(3).keys()]

신뢰할 수 있다

Array.from(Array(3).keys())

자세한 것은 이쪽

흥미로운 과제는 이를 위해 가장 짧은 함수를 작성하는 것입니다.구조대로의 재귀성!

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

ES6

Array.from 사용(여기 docs):

const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

ES6를 많이 사용하는 다소 미니멀한 실장은 다음과 같이 작성할 수 있으며, 스태틱 방식에 특히 주의를 기울입니다.

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

표준 Javascript에는 범위를 생성하는 기능이 내장되어 있지 않습니다.여러 javascript 프레임워크가 이러한 기능을 지원하거나 다른 사람들이 지적한 것처럼 언제든지 자신의 기능을 롤업할 수 있습니다.

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

이것은 PHP가 아닌, PHP의 모방품이지만,rangePython에서.

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] 

이것도 반대로 작동한다.

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 ]

특정 범위의 숫자 배열을 생성하는 경우 다음을 사용합니다.

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]

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

이걸 쓰세요.지정된 값(정의되지 않음)의 배열을 만듭니다.다음 예제에서는 인덱스가 100개이지만 여기서는 키만 필요하므로 관련이 없습니다.어레이는 항상 0 인덱스 기반이기 때문에 어레이에서는 100 + 1 이 사용됩니다.생성할 값이 100이면 인덱스는 0부터 시작됩니다.따라서 마지막 값은 항상 100이 아니라 99입니다.

range(2, 100);

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

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