Javascript/jQuery에서 두 숫자 사이에 모든 정수 배열 생성

Javascript/jQuery에서 두 숫자 사이에 모든 정수 배열 생성

다음 확인란이 있다고 가정합니다.

<input type="checkbox" value="1-25" />

찾고 있는 범위의 경계를 정의하는 두 개의 숫자를 얻으려면 다음 jQuery를 사용합니다.

var value = $(this).val();
var lowEnd = Number(value.split('-')[0]);
var highEnd = Number(value.split('-')[1]);

그 다음 다음 다음 사이의 모든 정수를 포함하는 배열을 작성하려면 어떻게 해야 합니까?lowEnd그리고.highEnd,포함하여lowEnd그리고.highEnd자신들?이 구체적인 예에서는 어레이가 다음과 같이 됩니다.

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]

var list = [];
for (var i = lowEnd; i <= highEnd; i++) {
    list.push(i);
}

ES6:

Array.from 사용(여기 docs):

console.log(
   Array.from({length:5},(v,k)=>k+1)
)

JavaScript ES6의 경우:

function range(start, end) {
  return Array(end - start + 1).fill().map((_, idx) => start + idx)
}
var result = range(9, 18); // [9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
console.log(result);

완전성을 위해, 여기 옵션과 함께 있습니다.step파라미터를 지정합니다.

function range(start, end, step = 1) {
  const len = Math.floor((end - start) / step) + 1
  return Array(len).fill().map((_, idx) => start + (idx * step))
}
var result = range(9, 18, 0.83);
console.log(result);

실제 프로젝트에서는 npm부터 사용하겠습니다.뒷걸음질도 서포트하고 있기 때문에, 멋집니다.

언더스코어 라이브러리 또는 로대시 라이브러리를 강력히 권장합니다.

http://underscorejs.org/ #range

(거의 호환성이 있습니다.lodash 실행은 빨라지지만 언더스코어는 doco IMHO가 더 우수합니다.)

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

두 도서관 모두 매우 유용한 유틸리티들이 많이 있다.

내 버전의 루프;)

var lowEnd = 1;
var highEnd = 25;
var arr = [];
while(lowEnd <= highEnd){
   arr.push(lowEnd++);
}

가장 빠른 방법

1. 대부분의 브라우저에서 더 빠릅니다.
2. 변수를 직접 설정하는 것이 푸시보다 빠릅니다.

기능:

var x=function(a,b,c,d){d=[];c=b-a+1;while(c--){d[c]=b--}return d},

theArray=x(lowEnd,highEnd);

또는

var arr=[],c=highEnd-lowEnd+1;
while(c--){arr[c]=highEnd--}

편집

가독판

var arr = [],
c = highEnd - lowEnd + 1;
while ( c-- ) {
 arr[c] = highEnd--
}

데모

http://jsfiddle.net/W3CUn/

다운보터용

성능

http://jsperf.com/for-push-while-set/2

ie에서는 고속, Firefox에서는 3배 고속

에어패드에서만 포루프가 조금 더 빠릅니다.

win8, osx10.8, ubuntu14.04, ipad, ipadair, ipod로 테스트 완료;

크롬,ff,즉,모바일 사파리로요

For loop이 최적화되지 않은 오래된 ie 브라우저에서 성능을 보고 싶습니다!

function range(j, k) { 
    return Array
        .apply(null, Array((k - j) + 1))
        .map(function(_, n){ return n + j; }); 
}

---

이것은 대략 와 동등하다

function range(j, k) { 
    var targetLength = (k - j) + 1;
    var a = Array(targetLength);
    var b = Array.apply(null, a);
    var c = b.map(function(_, n){ return n + j; });
    return c;
}

분해:

var targetLength = (k - j) + 1;

var a = Array(targetLength);

그러면 올바른 공칭 길이의 스파스 행렬이 생성됩니다.이제 스파스 행렬의 문제는 정확한 공칭 길이를 가지지만 실제 요소가 없다는 것입니다. 따라서, 다음과 같이,

j = 7, k = 13

console.log(a);

우리에게 준다

Array [ <7 empty slots> ]

그리고나서

var b = Array.apply(null, a);

는 sparse 매트릭스를 인수 리스트로 Array constructor에 전달합니다.Array constructor는 (실제) 길이의 target Length의 고밀도 매트릭스를 생성합니다.여기서 모든 요소는 정의되지 않은 값을 가집니다.첫 번째 인수는 어레이 컨스트럭터 함수 실행 컨텍스트의 'this' 값이며 여기서 역할을 하지 않으며 null도 마찬가지입니다.

그래서 지금.

 console.log(b);

수율

 Array [ undefined, undefined, undefined, undefined, undefined, undefined, undefined ]

마침내.

var c = b.map(function(_, n){ return n + j; });

는 Array.map 함수가 맵 위임/콜백에 전달한다는 사실을 이용합니다.1. 현재 요소의 값 및 2. 현재 요소의 인덱스.첫 번째 인수는 폐기되고 두 번째 인수는 시작 오프셋을 조정한 후 올바른 시퀀스 값을 설정하기 위해 사용할 수 있습니다.

그래서...

console.log(c);

수율

 Array [ 7, 8, 9, 10, 11, 12, 13 ]

내 5센트:

정수의 양방향 배열이 기능합니다.

범위(0, 5)가[0, 1, 2, 3, 4, 5].

범위(5, 0)는[5, 4, 3, 2, 1, 0].

이 답변에 근거해서.

function range(start, end) {
  const isReverse = (start > end);
  const targetLength = isReverse ? (start - end) + 1 : (end - start ) + 1;
  const arr = new Array(targetLength);
  const b = Array.apply(null, arr);
  const result = b.map((discard, n) => {
    return (isReverse) ? n + end : n + start;
  });

  return (isReverse) ? result.reverse() : result;
}

하기 위해서는 에서 arg를 체크해야 . args를 사용하다isFinite() ★★★★★★★★★★★★★★★★★」isNaN().

function createNumberArray(lowEnd, highEnd) {
    var start = lowEnd;
    var array = [start];
    while (start < highEnd) {
        array.push(start);
        start++;
    }
} 

시작이 항상 종료보다 작을 경우 다음을 수행할 수 있습니다.

function range(start, end) {
  var myArray = [];
  for (var i = start; i <= end; i += 1) {
    myArray.push(i);
  }
  return myArray;
};
console.log(range(4, 12));                 // → [4, 5, 6, 7, 8, 9, 10, 11, 12]

세 번째 인수를 사용하여 어레이 구축에 사용된 단계를 수정하고 시작 부분이 끝 부분보다 크더라도 작동하도록 하려면 다음 절차를 수행합니다.

function otherRange(start, end, step) {
  otherArray = [];
  if (step == undefined) {
    step = 1;
  };
  if (step > 0) {
    for (var i = start; i <= end; i += step) {
      otherArray.push(i);
    }
  } else {
    for (var i = start; i >= end; i += step) {
      otherArray.push(i);
    }
  };
  return otherArray;
};
console.log(otherRange(10, 0, -2));        // → [10, 8, 6, 4, 2, 0]
console.log(otherRange(10, 15));           // → [10, 11, 12, 13, 14, 15]
console.log(otherRange(10, 20, 2));        // → [10, 12, 14, 16, 18, 20]

이렇게 함수는 양의 스텝과 음의 스텝을 받아들이며 스텝을 지정하지 않으면 기본값은 1입니다.

var values = $(this).val().split('-'),
    i = +values[0],
    l = +values[1],
    range = [];

while (i < l) {
    range[range.length] = i;
    i += 1;
}

range[range.length] = l;

아마 DRYER의 루프 방법이 있을 것입니다만, 그것이 기본적인 생각입니다.

'시작' 숫자가 '끝' 수에 도달할 때까지 원하는 양만큼 증가하는 범위 방법을 설계할 수 있습니다.이 예에서는 from이 to보다 큰지 작은지에 따라 up 또는 down을 '카운트'합니다.

Array.range= function(from, to, step){
    if(typeof from== 'number'){
        var A= [from];
        step= typeof step== 'number'? Math.abs(step):1;
        if(from> to){
            while((from -= step)>= to) A.push(from);
        }
        else{
            while((from += step)<= to) A.push(from);
        }
        return A;
    }   
}

10진수 값 Array.range(0,1,.01)로 스텝업 하는 경우는 부동소수점 부정의 값을 잘라낼 필요가 있습니다.그렇지 않으면 0.06이 아닌 0.0600000000000005와 같은 숫자가 반환됩니다.

이렇게 하면 다른 버전에 약간의 오버헤드가 추가되지만 정수 또는 십진수 단계에서 올바르게 작동합니다.

Array.range= function(from, to, step, prec){
    if(typeof from== 'number'){
        var A= [from];
        step= typeof step== 'number'? Math.abs(step):1;
        if(!prec){
            prec= (from+step)%1? String((from+step)%1).length+1:0;
        }
        if(from> to){
            while(+(from -= step).toFixed(prec)>= to) A.push(+from.toFixed(prec));
        }
        else{
            while(+(from += step).toFixed(prec)<= to) A.push(+from.toFixed(prec));
        }
        return A;
    }   
}

순수 ES6를 탑재한 솔루션

위의 m59의 답변에서 영감을 얻었지만, 다음 질문에 의존하지 않고fill:

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

따라서 다음과 같이 사용할 수 있습니다.

range(3,5)
=> [3, 4, 5]

답변 목록에 http://minifiedjs.com/ 추가:)

코드는 언더스코어 및 기타 코드와 유사합니다.

var l123 = _.range(1, 4);      // same as _(1, 2, 3)
var l0123 = _.range(3);        // same as _(0, 1, 2)
var neg123 = _.range(-3, 0);   // same as _(-3, -2, -1)
var empty = _.range(2,1);      // same as _()

문서: http://minifiedjs.com/api/range.html

minized.js를 사용하는 이유는 설치 공간이 적고 구문을 이해하기 쉽기 때문입니다.저는 jQuery, Haird Js, Underscore/Sugar Js를 하나의 프레임워크로 대체하고 있습니다.

물론 언더스코어만큼 인기가 있는 것은 아닙니다.이것은 어떤 사람들에게는 걱정거리가 될 수 있다.

Miniated는 CC-0(퍼블릭 도메인) 라이선스를 사용하여 Tim Jansen에 의해 이용 가능하게 되었습니다.

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

출처 : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from

_Array = (length) => Object.keys(Array.from({length}))

//_Array = [0, 1, 2, 3, 4]

const range = (start: number, end: number) => {
  for (var i = start, list = []; i <= end; list.push(i), i++);
  return list;
};

아래 방법이 도움이 되기를 바랍니다.서 ★★★★count변수를 사용하여 배열 길이를 나타낼 수 있습니다.

const generateRandomArryOfNumbers = (min = 1, max = 100, count = 31) => {
  return Array.from(new Array(count), () =>
    Math.floor(Math.random() * (max - min + 1) + min)
  );
};

밑줄로 해결

data = [];
_.times( highEnd, function( n ){ data.push( lowEnd ++ ) } );

        function getRange(a,b)
        {
            ar = new Array();
            var y = a - b > 0 ? a - b : b - a;
            for (i=1;i<y;i++)
            {
                ar.push(i+b);
            }
            return ar;
        }

언급URL : https://stackoverflow.com/questions/8069315/create-array-of-all-integers-between-two-numbers-inclusive-in-javascript-jquer