blocks|key|907217|text|标准的Javascript没有内置的函数来生成范围。有几个javascript框架添加了对这些特性的支持，或者正如其他人指出的那样，您可以随时使用自己的特性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907218|如果你想仔细检查一下，最权威的资源是ECMA-262+Standard。|offset|length|907219|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ecma-international.org/publications/standards/Ecma-262.htm^0|0|I|H|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

<p>The standard Javascript doesn't have a built-in function to generate ranges.  Several javascript frameworks add support for such features, or as others have pointed out you can always roll your own.</p>

<p>If you'd like to double-check, the definitive resource is the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm" rel="nofollow noreferrer">ECMA-262 Standard</a>.</p>


blocks|key|907287|text|它适用于字符和数字，通过一个可选的步骤向前或向后移动。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907288|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"+%7C%7C+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+%2B=+step;
++++++++}

++++}+else+if+(typeofStart+==+"string")+{

++++++++if+(start.length+!=+1+%7C%7C+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+%2B=+step;
++++++++}

++++}+else+{
++++++++throw+TypeError("Only+string+and+number+types+are+supported");
++++}

++++return+range;

}|code-block|syntax|javascript|907289|jsFiddle。|offset|length|907290|如果您喜欢扩充本机类型，则将其分配给Array.range。|style|CODE|907291|​|907292|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"+%7C%7C+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+%2B=+step;
++++++++}

++++}+else+if+(typeofStart+==+"string")+{

++++++++if+(start.length+!=+1+%7C%7C+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+%2B=+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));|907293|907294|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/ZaZAZ/^0|0|0|0|8|0|0|I|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@]|9|@$I|14|J|15|1|16]]|A|$]]|$1|K|3|L|5|6|7|17|8|@$I|18|J|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|S|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

<p>It works for characters and numbers, going forwards or backwards with an optional step.</p>

<pre><code>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" &amp;&amp; (step = 1);

    if (end &lt; start) {
        step = -step;
    }

    if (typeofStart == "number") {

        while (step &gt; 0 ? end &gt;= start : end &lt;= 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 &gt; 0 ? end &gt;= start : end &lt;= start) {
            range.push(String.fromCharCode(start));
            start += step;
        }

    } else {
        throw TypeError("Only string and number types are supported");
    }

    return range;

}
</code></pre>

<p><a href="http://jsfiddle.net/ZaZAZ/" rel="noreferrer">jsFiddle</a>.</p>

<p>If augmenting native types is your thing, then assign it to <code>Array.range</code>.</p>

<p><div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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" &amp;&amp; (step = 1);

    if (end &lt; start) {
        step = -step;
    }

    if (typeofStart == "number") {

        while (step &gt; 0 ? end &gt;= start : end &lt;= 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 &gt; 0 ? end &gt;= start : end &lt;= 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));</code></pre>
</div>
</div>
</p>


blocks|key|907306|text|Array.range+=+function(a,+b,+step){
++++var+A+=+[];
++++if(typeof+a+==+'number'){
++++++++A[0]+=+a;
++++++++step+=+step+%7C%7C+1;
++++++++while(a%2Bstep+<=+b){
++++++++++++A[A.length]=+a%2B=+step;
++++++++}
++++}
++++else+{
++++++++var+s+=+'abcdefghijklmnopqrstuvwxyz';
++++++++if(a+===+a.toUpperCase()){
++++++++++++b+=+b.toUpperCase();
++++++++++++s+=+s.toUpperCase();
++++++++}
++++++++s+=+s.substring(s.indexOf(a),+s.indexOf(b)%2B+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']|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|907307|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Array.range = function(a, b, step){
    var A = [];
    if(typeof a == 'number'){
        A[0] = a;
        step = step || 1;
        while(a+step &lt;= 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']
</code></pre>


blocks|key|907348|text|简单的范围函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907349|function+range(start,+stop,+step)+{
++++var+a+=+[start],+b+=+start;
++++while+(b+<+stop)+{
++++++++a.push(b+%2B=+step+%7C%7C+1);
++++}
++++return+a;
}|code-block|syntax|javascript|907350|907351|要合并BigInt+data+type，可以包含一些检查，以确保所有变量都是相同的typeof+start|offset|length|style|CODE|907352|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+%7C%7C+1;
++++while+(b+<+stop)+{
++++++++a.push(b+%2B=+step);
++++}
++++return+a;
}|907353|907354|要删除比stop定义的值更高的值，例如range(0,5,2)将包含6，这不应该包含。|907355|function+range(start,+stop,+step)+{
++++var+a+=+[start],+b+=+start;
++++while+(b+<+stop)+{
++++++++a.push(b+%2B=+step+%7C%7C+1);
++++}
++++return+(b+>+stop)+?+a.slice(0,-1)+:+a;
}|907356|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt^0|0|0|0|15|C|3|G|0|0|0|0|4|4|J|C|Y|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@$J|16|K|17|L|M]]|9|@$J|18|K|19|1|1A]]|A|$]]|$1|N|3|O|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|P|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@$J|1E|K|1F|L|M]|$J|1G|K|1H|L|M]|$J|1I|K|1J|L|M]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

<p>Simple range function:</p>
<pre><code>function range(start, stop, step) {
    var a = [start], b = start;
    while (b &lt; stop) {
        a.push(b += step || 1);
    }
    return a;
}
</code></pre>
<hr />
<p>To incorporate the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt" rel="noreferrer">BigInt data type</a> some check can be included,  ensuring that all variables are same <code>typeof start</code>:</p>
<pre><code>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 &lt; stop) {
        a.push(b += step);
    }
    return a;
}
</code></pre>
<hr />
<p>To remove values higher than defined by <code>stop</code> e.g. <code>range(0,5,2)</code> will include <code>6</code>, which shouldn't be.</p>
<pre><code>function range(start, stop, step) {
    var a = [start], b = start;
    while (b &lt; stop) {
        a.push(b += step || 1);
    }
    return (b &gt; stop) ? a.slice(0,-1) : a;
}
</code></pre>


blocks|key|1122331|text|这是我的2分钱：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1122332|function+range(start,+end)+{
++return+Array.apply(0,+Array(end+-+1))
++++.map((element,+index)+=>+index+%2B+start);
}|code-block|syntax|javascript|1122333|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here's my 2 cents:</p>
<pre><code>function range(start, end) {
  return Array.apply(0, Array(end - 1))
    .map((element, index) =&gt; index + start);
}
</code></pre>


blocks|key|1122413|text|我发现了一个JS范围函数，相当于PHP语言中的那个，而且它的here效果非常好。向前和向后工作，可以处理整数、浮点数和字母表！|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1122414|function+range(low,+high,+step)+{
++//++discuss+at:+http://phpjs.org/functions/range/
++//+original+by:+Waldo+Malqui+Silva
++//+++example+1:+range+(+0,+12+);
++//+++returns+1:+[0,+1,+2,+3,+4,+5,+6,+7,+8,+9,+10,+11,+12]
++//+++example+2:+range(+0,+100,+10+);
++//+++returns+2:+[0,+10,+20,+30,+40,+50,+60,+70,+80,+90,+100]
++//+++example+3:+range(+'a',+'i'+);
++//+++returns+3:+['a',+'b',+'c',+'d',+'e',+'f',+'g',+'h',+'i']
++//+++example+4:+range(+'c',+'a'+);
++//+++returns+4:+['c',+'b',+'a']

++var+matrix+=+[];
++var+inival,+endval,+plus;
++var+walker+=+step+%7C%7C+1;
++var+chars+=+false;

++if+(!isNaN(low)+&&+!isNaN(high))+{
++++inival+=+low;
++++endval+=+high;
++}+else+if+(isNaN(low)+&&+isNaN(high))+{
++++chars+=+true;
++++inival+=+low.charCodeAt(0);
++++endval+=+high.charCodeAt(0);
++}+else+{
++++inival+=+(isNaN(low)+?+0+:+low);
++++endval+=+(isNaN(high)+?+0+:+high);
++}

++plus+=+((inival+>+endval)+?+false+:+true);
++if+(plus)+{
++++while+(inival+<=+endval)+{
++++++matrix.push(((chars)+?+String.fromCharCode(inival)+:+inival));
++++++inival+%2B=+walker;
++++}
++}+else+{
++++while+(inival+>=+endval)+{
++++++matrix.push(((chars)+?+String.fromCharCode(inival)+:+inival));
++++++inival+-=+walker;
++++}
++}

++return+matrix;
}|code-block|syntax|javascript|1122415|下面是精简版：|1122416|function+range(h,c,b){var+i=[];var+d,f,e;var+a=b%7C%7C1;var+g=false;if(!isNaN(h)&&!isNaN(c)){d=h;f=c}else{if(isNaN(h)&&isNaN(c)){g=true;d=h.charCodeAt(0);f=c.charCodeAt(0)}else{d=(isNaN(h)?0:h);f=(isNaN(c)?0:c)}}e=((d>f)?false:true);if(e){while(d<=f){i.push(((g)?String.fromCharCode(d):d));d%2B=a}}else{while(d>=f){i.push(((g)?String.fromCharCode(d):d));d-=a}}return+i};|1122417|entityMap|0|LINK|mutability|MUTABLE|url|http://phpjs.org/functions/range/^0|U|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<p>I found a JS range function equivalent to the one in PHP, and works amazingly great <a href="http://phpjs.org/functions/range/" rel="nofollow">here</a>. Works forward &amp; backward, and works with integers, floats and alphabets!</p>

<pre><code>function range(low, high, step) {
  //  discuss at: http://phpjs.org/functions/range/
  // original by: Waldo Malqui Silva
  //   example 1: range ( 0, 12 );
  //   returns 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
  //   example 2: range( 0, 100, 10 );
  //   returns 2: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
  //   example 3: range( 'a', 'i' );
  //   returns 3: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
  //   example 4: range( 'c', 'a' );
  //   returns 4: ['c', 'b', 'a']

  var matrix = [];
  var inival, endval, plus;
  var walker = step || 1;
  var chars = false;

  if (!isNaN(low) &amp;&amp; !isNaN(high)) {
    inival = low;
    endval = high;
  } else if (isNaN(low) &amp;&amp; isNaN(high)) {
    chars = true;
    inival = low.charCodeAt(0);
    endval = high.charCodeAt(0);
  } else {
    inival = (isNaN(low) ? 0 : low);
    endval = (isNaN(high) ? 0 : high);
  }

  plus = ((inival &gt; endval) ? false : true);
  if (plus) {
    while (inival &lt;= endval) {
      matrix.push(((chars) ? String.fromCharCode(inival) : inival));
      inival += walker;
    }
  } else {
    while (inival &gt;= endval) {
      matrix.push(((chars) ? String.fromCharCode(inival) : inival));
      inival -= walker;
    }
  }

  return matrix;
}
</code></pre>

<p>And here is the minified version:</p>

<pre><code>function range(h,c,b){var i=[];var d,f,e;var a=b||1;var g=false;if(!isNaN(h)&amp;&amp;!isNaN(c)){d=h;f=c}else{if(isNaN(h)&amp;&amp;isNaN(c)){g=true;d=h.charCodeAt(0);f=c.charCodeAt(0)}else{d=(isNaN(h)?0:h);f=(isNaN(c)?0:c)}}e=((d&gt;f)?false:true);if(e){while(d&lt;=f){i.push(((g)?String.fromCharCode(d):d));d+=a}}else{while(d&gt;=f){i.push(((g)?String.fromCharCode(d):d));d-=a}}return i};
</code></pre>


blocks|key|1122477|text|对于更像ruby的方法，具有良好的向后兼容性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1122478|range([begin],+end+=+0)，其中begin和end是数字|offset|length|style|CODE|1122479|var+range+=+function(begin,+end)+{
++if+(typeof+end+===+"undefined")+{
++++end+=+begin;+begin+=+0;
++}
++var+result+=+[],+modifier+=+end+>+begin+?+1+:+-1;
++for+(+var+i+=+0;+i+<=+Math.abs(end+-+begin);+i%2B%2B+)+{
++++result.push(begin+%2B+i+*+modifier);
++}
++return+result;
}|code-block|syntax|javascript|1122480|示例：|1122481|range(3);+//=>+[0,+1,+2,+3]
range(-2);+//=>+[0,+-1,+-2]
range(1,+2)+//=>+[1,+2]
range(1,+-2);+//=>+[1,+0,+-1,+-2]|1122482|entityMap^0|0|0|N|Q|5|W|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

<p>For a more ruby-like approach with good backward compatibility:</p>

<p><code>range([begin], end = 0)</code> where <code>begin</code> and <code>end</code> are numbers</p>

<pre><code>var range = function(begin, end) {
  if (typeof end === "undefined") {
    end = begin; begin = 0;
  }
  var result = [], modifier = end &gt; begin ? 1 : -1;
  for ( var i = 0; i &lt;= Math.abs(end - begin); i++ ) {
    result.push(begin + i * modifier);
  }
  return result;
}
</code></pre>

<p>Examples:</p>

<pre><code>range(3); //=&gt; [0, 1, 2, 3]
range(-2); //=&gt; [0, -1, -2]
range(1, 2) //=&gt; [1, 2]
range(1, -2); //=&gt; [1, 0, -1, -2]
</code></pre>


blocks|key|907590|text|使用和声spread+operator和箭头函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|907591|var+range+=+(start,+end)+=>+[...Array(end+-+start+%2B+1)].map((_,+i)+=>+start+%2B+i);|code-block|syntax|javascript|907592|示例：|907593|range(10,+15);
[+10,+11,+12,+13,+14,+15+]|907594|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator^0|4|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<p>Using Harmony <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> and arrow functions:</p>

<pre><code>var range = (start, end) =&gt; [...Array(end - start + 1)].map((_, i) =&gt; start + i);
</code></pre>

<p>Example:</p>

<pre><code>range(10, 15);
[ 10, 11, 12, 13, 14, 15 ]
</code></pre>


blocks|key|1122551|text|您可以使用lodash函数_.range(10)+https://lodash.com/docs#range|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1122552|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs#range^0|5|6|D|B|P|T|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

<p>you can use <code>lodash</code> function <code>_.range(10)</code> <a href="https://lodash.com/docs#range" rel="noreferrer">https://lodash.com/docs#range</a></p>


blocks|key|1122599|text|对于号码，您可以使用ES6+Array.from()、which+works+in+everything+these+days，IE除外：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1122600|较短的版本：|1122601|Array.from({length:+20},+(x,+i)+=>+i);|code-block|syntax|javascript|1122602|更长的版本：|1122603|Array.from(new+Array(20),+(x,+i)+=>+i);​​​​​​|1122604|它创建了一个从0到19+(包括0到19)的数组。这可以进一步缩写为以下形式之一：|1122605|Array.from(Array(20).keys());
//+or
[...Array(20).keys()];|1122606|也可以指定下限和上限，例如：|1122607|Array.from(new+Array(20),+(x,+i)+=>+i+%2B+*lowerBound*);|1122608|更详细地描述这一点的一篇文章：http://www.2ality.com/2014/05/es6-array-methods.html|1122609|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/from?v=example#Browser_compatibility|1|http://www.2ality.com/2014/05/es6-array-methods.html^0|E|C|R|10|0|0|0|0|0|0|0|0|0|0|F|1G|1|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|F|3|G|5|6|7|1G|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1I|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1K|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1M|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1O|8|@]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|10|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]|18|$5|13|14|15|E|$16|19]]]]

<p>For numbers you can use ES6 <code>Array.from()</code>, <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/from?v=example#Browser_compatibility" rel="noreferrer">which works in everything these days</a> except IE:</p>
<p>Shorter version:</p>
<pre><code>Array.from({length: 20}, (x, i) =&gt; i);
</code></pre>
<p>Longer version:</p>
<pre><code>Array.from(new Array(20), (x, i) =&gt; i);​​​​​​
</code></pre>
<p>which creates an array from 0 to 19 inclusive. This can be further shortened to one of these forms:</p>
<pre><code>Array.from(Array(20).keys());
// or
[...Array(20).keys()];
</code></pre>
<p>Lower and upper bounds can be specified too, for example:</p>
<pre><code>Array.from(new Array(20), (x, i) =&gt; i + *lowerBound*);
</code></pre>
<p>An article describing this in more detail: <a href="http://www.2ality.com/2014/05/es6-array-methods.html" rel="noreferrer">http://www.2ality.com/2014/05/es6-array-methods.html</a></p>


blocks|key|907720|text|对于为给定范围生成数字数组，我使用以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907721|function+range(start,+stop)
{
++++var+array+=+[];

++++var+length+=+stop+-+start;+

++++for+(var+i+=+0;+i+<=+length;+i%2B%2B)+{+
++++++++array[i]+=+start;
++++++++start%2B%2B;
++++}

++++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]|code-block|syntax|javascript|907722|显然，它不适用于按字母顺序排列的数组。|907723|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>As far as generating a numeric array for a given range, I use this:  </p>

<pre><code>function range(start, stop)
{
    var array = [];

    var length = stop - start; 

    for (var i = 0; i &lt;= 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]
</code></pre>

<p>Obviously, it won't work for alphabetical arrays.</p>


blocks|key|907767|text|我在Eloquent+JavaScript中做了这样的练习|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907768|function+range(start,+end,+step)+{
++var+ar+=+[];
++if+(start+<+end)+{
++++if+(arguments.length+==+2)+step+=+1;
++++for+(var+i+=+start;+i+<=+end;+i+%2B=+step)+{
++++++ar.push(i);
++++}
++}
++else+{
++++if+(arguments.length+==+2)+step+=+-1;
++++for+(var+i+=+start;+i+>=+end;+i+%2B=+step)+{
++++++ar.push(i);
++++}
++}
++return+ar;
}|code-block|syntax|javascript|907769|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>just made something like this as an exercise in Eloquent JavaScript</p>

<pre><code>function range(start, end, step) {
  var ar = [];
  if (start &lt; end) {
    if (arguments.length == 2) step = 1;
    for (var i = start; i &lt;= end; i += step) {
      ar.push(i);
    }
  }
  else {
    if (arguments.length == 2) step = -1;
    for (var i = start; i &gt;= end; i += step) {
      ar.push(i);
    }
  }
  return ar;
}
</code></pre>


blocks|key|907795|text|function+check(){

++++var+correct=true;

++++for(var+i=0;+i<arguments.length;+i%2B%2B){

++++if(typeof+arguments[i]+!=+"number"){

++++correct=false;++}+}+return+correct;+}+++

//------------------------------------------

+function+range(start,step,end){

++var+correct=check(start,step,end);

++if(correct+&&+(step+&&+end)!=0){+

++for(var+i=start;+i<=end;+i%2B=step)

++document.write(i%2B"+");+}

++else+document.write("Not+Correct+Data");+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|907796|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function check(){

    var correct=true;

    for(var i=0; i&lt;arguments.length; i++){

    if(typeof arguments[i] != "number"){

    correct=false;  } } return correct; }   

//------------------------------------------

 function range(start,step,end){

  var correct=check(start,step,end);

  if(correct &amp;&amp; (step &amp;&amp; end)!=0){ 

  for(var i=start; i&lt;=end; i+=step)

  document.write(i+" "); }

  else document.write("Not Correct Data"); }
</code></pre>


blocks|key|907827|text|我会像这样编写代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907828|function+range(start,+end)+{
++++return+Array(end-start).join(0).split(0).map(function(val,+id)+{return+id%2Bstart});
}++

range(-4,2);
//+[-4,-3,-2,-1,0,1]

range(3,9);
//+[3,4,5,6,7,8]|code-block|syntax|javascript|907829|它的行为类似于Python+range：|907830|>>>+range(-4,2)
[-4,+-3,+-2,+-1,+0,+1]|907831|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>I would code something like this:</p>

<pre><code>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]
</code></pre>

<p>It behaves similarly to Python range:</p>

<pre><code>&gt;&gt;&gt; range(-4,2)
[-4, -3, -2, -1, 0, 1]
</code></pre>


blocks|key|907890|text|您可以使用带有数组、for循环和Math.random()变量的函数来解决此问题。for循环将数字推入数组，该数组将包含您范围内的所有数字。然后Math.random()根据数组的长度随机选择一个数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907891|function+randNumInRange(min,+max)+{
++var+range+=+[]
++for(var+count+=+min;+count+<=+max;+count%2B%2B)+{
++++range.push(count);
++}
++var+randNum+=+Math.floor(Math.random()+*+range.length);
++alert(range[randNum]);
}|code-block|syntax|javascript|907892|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>You can use a function with an array, a for loop, and a Math.random() variable to solve that. The for loop pushes numbers into the array, which will contain all the numbers in your range. Then the Math.random() randomly selects one, based on the array's length.</p>

<pre><code>function randNumInRange(min, max) {
  var range = []
  for(var count = min; count &lt;= max; count++) {
    range.push(count);
  }
  var randNum = Math.floor(Math.random() * range.length);
  alert(range[randNum]);
}
</code></pre>


blocks|key|907910|text|解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907911|//best+performance
var+range+=+function(start,+stop,+step)+{
++++var+a+=+[start];
++++while+(start+<+stop)+{
++++++++start+%2B=+step+%7C%7C+1;
++++++++a.push(start);
++++}
++++return+a;
};

//or
var+range+=+function(start,+end)+{
++++return+Array(%2B%2Bend-start).join(0).split(0).map(function(n,+i)+{
++++++++return+i%2Bstart
++++});
}|code-block|syntax|javascript|907912|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Solution:</p>

<pre><code>//best performance
var range = function(start, stop, step) {
    var a = [start];
    while (start &lt; stop) {
        start += step || 1;
        a.push(start);
    }
    return a;
};

//or
var range = function(start, end) {
    return Array(++end-start).join(0).split(0).map(function(n, i) {
        return i+start
    });
}
</code></pre>


blocks|key|1122912|text|我很惊讶地发现这个帖子并不像我的解决方案(可能我错过了一个答案)，所以它就在这里。我在ES6语法中使用了一个简单的范围函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1122913|//+[begin,+end[
const+range+=+(b,+e)+=>+Array.apply(null,+Array(e+-+b)).map((_,+i)+=>+{return+i%2Bb;});|code-block|syntax|javascript|1122914|但它只有在向前计数时才有效(即。begin+<+end)，所以我们可以在需要的时候稍微修改一下，如下所示：|1122915|const+range+=+(b,+e)+=>+Array.apply(null,+Array(Math.abs(e+-+b))).map((_,+i)+=>+{return+b+<+e+?+i%2Bb+:+b-i;});|1122916|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>I was surprised to come across this thread and see nothing like my solution (maybe I missed an answer), so here it is.
I use a simple range function in ES6 syntax :</p>

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

<p>But it works only when counting forward (ie. begin &lt; end), so we can modify it slightly when needed like so : </p>

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


blocks|key|1122980|text|我的take在for循环中使用条件三元运算符(尽管没有参数测试)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1122981|function+range(start,end,step){
+++var+resar+=+[];
+++for+(var+i=start;(step<0+?+i>=end:i<=end);+i+%2B=+(step+==+undefined+?+1:step)){
+++++++resar.push(i);
+++++};
+++return+resar;
};|code-block|syntax|javascript|1122982|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>My take using conditional ternary operators in the for loop (no argument testing, though).</p>

<pre><code>function range(start,end,step){
   var resar = [];
   for (var i=start;(step&lt;0 ? i&gt;=end:i&lt;=end); i += (step == undefined ? 1:step)){
       resar.push(i);
     };
   return resar;
};
</code></pre>


blocks|key|908063|text|这是我模仿Python的解决方案。在底部，你可以找到一些如何使用它的例子。它可以处理数字，就像Python的range一样|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|908064|var+assert+=+require('assert');++++//+if+you+use+Node,+otherwise+remove+the+asserts

var+L+=+{};++++//+L,+i.e.+'list'

//+range(start,+end,+step)
L.range+=+function+(a,+b,+c)+{
++++assert(arguments.length+>=+1+&&+arguments.length+<=+3);
++++if+(arguments.length+===+3)+{
++++++++assert(c+!=+0);
++++}

++++var+li+=+[],
++++++++i,
++++++++start,+end,+step,
++++++++up+=+true;++++//+Increasing+or+decreasing+order?+Default:+increasing.

++++if+(arguments.length+===+1)+{
++++++++start+=+0;
++++++++end+=+a;
++++++++step+=+1;
++++}

++++if+(arguments.length+===+2)+{
++++++++start+=+a;
++++++++end+=+b;
++++++++step+=+1;
++++}

++++if+(arguments.length+===+3)+{
++++++++start+=+a;
++++++++end+=+b;
++++++++step+=+c;
++++++++if+(c+<+0)+{
++++++++++++up+=+false;
++++++++}
++++}

++++if+(up)+{
++++++++for+(i+=+start;+i+<+end;+i+%2B=+step)+{
++++++++++++li.push(i);
++++++++}
++++}+else+{
++++++++for+(i+=+start;+i+>+end;+i+%2B=+step)+{
++++++++++++li.push(i);
++++++++}
++++}

++++return+li;
}|code-block|syntax|javascript|908065|示例：|908066|//+range
L.range(0)+->+[]
L.range(1)+->+[0]
L.range(2)+->+[0,+1]
L.range(5)+->+[0,+1,+2,+3,+4]

L.range(1,+5)+->+[1,+2,+3,+4]
L.range(6,+4)+->+[]
L.range(-2,+2)+->+[-2,+-1,+0,+1]

L.range(1,+5,+1)+->+[1,+2,+3,+4]
L.range(0,+10,+2)+->+[0,+2,+4,+6,+8]
L.range(10,+2,+-1)+->+[10,+9,+8,+7,+6,+5,+4,+3]
L.range(10,+2,+-2)+->+[10,+8,+6,+4]|908067|entityMap^0|1I|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

<p>Here is my solution that mimics Python. At the bottom you can find some examples how to use it. It works with numbers, just like Python's <code>range</code>:</p>

<pre><code>var assert = require('assert');    // if you use Node, otherwise remove the asserts

var L = {};    // L, i.e. 'list'

// range(start, end, step)
L.range = function (a, b, c) {
    assert(arguments.length &gt;= 1 &amp;&amp; arguments.length &lt;= 3);
    if (arguments.length === 3) {
        assert(c != 0);
    }

    var li = [],
        i,
        start, end, step,
        up = true;    // Increasing or decreasing order? Default: increasing.

    if (arguments.length === 1) {
        start = 0;
        end = a;
        step = 1;
    }

    if (arguments.length === 2) {
        start = a;
        end = b;
        step = 1;
    }

    if (arguments.length === 3) {
        start = a;
        end = b;
        step = c;
        if (c &lt; 0) {
            up = false;
        }
    }

    if (up) {
        for (i = start; i &lt; end; i += step) {
            li.push(i);
        }
    } else {
        for (i = start; i &gt; end; i += step) {
            li.push(i);
        }
    }

    return li;
}
</code></pre>

<p>Examples:</p>

<pre><code>// range
L.range(0) -&gt; []
L.range(1) -&gt; [0]
L.range(2) -&gt; [0, 1]
L.range(5) -&gt; [0, 1, 2, 3, 4]

L.range(1, 5) -&gt; [1, 2, 3, 4]
L.range(6, 4) -&gt; []
L.range(-2, 2) -&gt; [-2, -1, 0, 1]

L.range(1, 5, 1) -&gt; [1, 2, 3, 4]
L.range(0, 10, 2) -&gt; [0, 2, 4, 6, 8]
L.range(10, 2, -1) -&gt; [10, 9, 8, 7, 6, 5, 4, 3]
L.range(10, 2, -2) -&gt; [10, 8, 6, 4]
</code></pre>


blocks|key|908115|text|如果我们输入像[4,+2]这样的东西，我们将得到[2,+3,+4]作为输出，我们可以使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|908116|function+createRange(array)+{
++var+range+=+[];
++var+highest+=+array.reduce(function(a,+b)+{
++++return+Math.max(a,+b);
++});
++var+lowest+=+array.reduce(function(a,+b)+{
++++return+Math.min(a,+b);
++});
++for+(var+i+=+lowest;+i+<=+highest;+i%2B%2B)+{
++++range.push(i);
++}
++return+range;
}|code-block|syntax|javascript|908117|entityMap^0|7|6|O|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

<p>If we input something like <code>[4, 2]</code>, we’ll get <code>[2, 3, 4]</code> as output, we can work with that.</p>

<pre><code>function createRange(array) {
  var range = [];
  var highest = array.reduce(function(a, b) {
    return Math.max(a, b);
  });
  var lowest = array.reduce(function(a, b) {
    return Math.min(a, b);
  });
  for (var i = lowest; i &lt;= highest; i++) {
    range.push(i);
  }
  return range;
}
</code></pre>


blocks|key|1123134|text|按照2010年的规范进行编码(是的，现在是2016年，有了ES6生成器)。下面是我的观点，其中包含模拟Python的range()函数的选项。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1123135|Array.range+=+function(start,+end,+step){
++++if+(start+==+undefined)+{+return+[]+}+//+"undefined"+check

++++if+(+(step+===+0)+)++{++return+[];+//+vs.+throw+TypeError("Invalid+'step'+input")
++++}++//+"step"+==+0++check

++++if+(typeof+start+==+'number')+{+//+number+check
++++++++if+(typeof+end+==+'undefined')+{+//+single+argument+input
++++++++++++end+=+start;
++++++++++++start+=+0;
++++++++++++step+=+1;
++++++++}
++++++++if+((!step)+%7C%7C+(typeof+step+!=+'number'))+{
++++++++++step+=+end+<+start+?+-1+:+1;
++++++++}

++++++++var+length+=+Math.max(Math.ceil((end+-+start)+/+step),+0);
++++++++var+out+=+Array(length);

++++++++for+(var+idx+=+0;+idx+<+length;+idx%2B%2B,+start+%2B=+step)+{
++++++++++out[idx]+=+start;
++++++++}

++++++++//+Uncomment+to+check+"end"+in+range()+output,+non+pythonic
++++++++if+(+(out[out.length-1]+%2B+step)+==+end+)+{+//+"end"+check
++++++++++++out.push(end)
++++++++}

++++}+else+{+
++++++++//+Historical:+'&'+is+the+27th+letter:+http://nowiknow.com/and-the-27th-letter-of-the-alphabet/
++++++++//+Axiom:+'a'+<+'z'+and+'z'+<+'A'
++++++++//+note:+'a'+>+'A'+==+true+("small+a+>+big+A",+try+explaining+it+to+a+kid!+)

++++++++var+st+=+'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&';+//+axiom+ordering

++++++++if+(typeof+end+==+'undefined')+{+//+single+argument+input
++++++++++++end+=+start;
++++++++++++start+=+'a';
++++++++}

++++++++var+first+=+st.indexOf(start);
++++++++var+last+=+st.indexOf(end);

++++++++if+((!step)+%7C%7C+(typeof+step+!=+'number'))+{
++++++++++step+=+last+<+first+?+-1+:+1;
++++++++}

++++++++if+((first+==+-1)+%7C%7C+(last+==+-1+))+{+//+check+'first'+&+'last'
++++++++++++return+[]
++++++++}

++++++++var+length+=+Math.max(Math.ceil((last+-+first)+/+step),+0);
++++++++var+out+=+Array(length);

++++++++for+(var+idx+=+0;+idx+<+length;+idx%2B%2B,+first+%2B=+step)+{
++++++++++out[idx]+=+st[first];
++++++++}+

++++++++//+Uncomment+to+check+"end"+in+range()+output,+non+pythonic
++++++++if+(+(st.indexOf(out[out.length-1])+%2B+step+)+==+last+)+{+//+"end"+check
++++++++++++out.push(end)
++++++++}
++++}
++++return+out;
}|code-block|syntax|javascript|1123136|示例：|1123137|Array.range(5);+++++++//+[0,1,2,3,4,5]
Array.range(4,-4,-2);+//+[4,+2,+0,+-2,+-4]
Array.range('a','d');+//+["a",+"b",+"c",+"d"]
Array.range('B','y');+//+["B",+"A",+"z",+"y"],+different+from+chr()+ordering
Array.range('f');+++++//+["a",+"b",+"c",+"d",+"e",+"f"]
Array.range(-5);++++++//+[],+similar+to+python
Array.range(-5,0)+++++//+[-5,-4-,-3-,-2,-1,0]|1123138|entityMap^0|1M|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

<p>Coded to 2010 specs (ya, it is 2016 with ES6 generators). Here's my take, with options to emulate the Python's <code>range()</code> function. </p>

<pre><code>Array.range = function(start, end, step){
    if (start == undefined) { return [] } // "undefined" check

    if ( (step === 0) )  {  return []; // vs. throw TypeError("Invalid 'step' input")
    }  // "step" == 0  check

    if (typeof start == 'number') { // number check
        if (typeof end == 'undefined') { // single argument input
            end = start;
            start = 0;
            step = 1;
        }
        if ((!step) || (typeof step != 'number')) {
          step = end &lt; start ? -1 : 1;
        }

        var length = Math.max(Math.ceil((end - start) / step), 0);
        var out = Array(length);

        for (var idx = 0; idx &lt; length; idx++, start += step) {
          out[idx] = start;
        }

        // Uncomment to check "end" in range() output, non pythonic
        if ( (out[out.length-1] + step) == end ) { // "end" check
            out.push(end)
        }

    } else { 
        // Historical: '&amp;' is the 27th letter: http://nowiknow.com/and-the-27th-letter-of-the-alphabet/
        // Axiom: 'a' &lt; 'z' and 'z' &lt; 'A'
        // note: 'a' &gt; 'A' == true ("small a &gt; big A", try explaining it to a kid! )

        var st = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&amp;'; // axiom ordering

        if (typeof end == 'undefined') { // single argument input
            end = start;
            start = 'a';
        }

        var first = st.indexOf(start);
        var last = st.indexOf(end);

        if ((!step) || (typeof step != 'number')) {
          step = last &lt; first ? -1 : 1;
        }

        if ((first == -1) || (last == -1 )) { // check 'first' &amp; 'last'
            return []
        }

        var length = Math.max(Math.ceil((last - first) / step), 0);
        var out = Array(length);

        for (var idx = 0; idx &lt; length; idx++, first += step) {
          out[idx] = st[first];
        } 

        // Uncomment to check "end" in range() output, non pythonic
        if ( (st.indexOf(out[out.length-1]) + step ) == last ) { // "end" check
            out.push(end)
        }
    }
    return out;
}
</code></pre>

<p>Example:</p>

<pre><code>Array.range(5);       // [0,1,2,3,4,5]
Array.range(4,-4,-2); // [4, 2, 0, -2, -4]
Array.range('a','d'); // ["a", "b", "c", "d"]
Array.range('B','y'); // ["B", "A", "z", "y"], different from chr() ordering
Array.range('f');     // ["a", "b", "c", "d", "e", "f"]
Array.range(-5);      // [], similar to python
Array.range(-5,0)     // [-5,-4-,-3-,-2,-1,0]
</code></pre>


blocks|key|908167|text|var+range+=+(l,r)+=>+new+Array(r+-+l).fill().map((_,k)+=>+k+%2B+l);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|908168|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var range = (l,r) =&gt; new Array(r - l).fill().map((_,k) =&gt; k + l);
</code></pre>


blocks|key|908217|text|使用range(start，stop，step)签名完成ES6实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908218|function+range(start,+stop,+step=1){
++if(!stop){stop=start;start=0;}
++return+Array.from(new+Array(int((stop-start)/step)),+(x,i)+=>+start%2B+i*step)
}|code-block|syntax|javascript|908219|如果要自动执行负步进，请添加|908220|if(stop<start)step=-Math.abs(step)|908221|或者更简单地说：|908222|range=(b,+e,+step=1)=>{
++if(!e){e=b;b=0}
++return+Array.from(new+Array(int((e-b)/step)),+(_,i)+=>+b<e?+b%2Bi*step+:+b-i*step)
}|908223|如果你有很大的范围，看看Paolo+Moretti的生成器方法|908224|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

<p>Complete ES6 implementation using range([start, ]stop[, step]) signature:</p>

<pre><code>function range(start, stop, step=1){
  if(!stop){stop=start;start=0;}
  return Array.from(new Array(int((stop-start)/step)), (x,i) =&gt; start+ i*step)
}
</code></pre>

<p>If you want automatic negative stepping, add</p>

<pre><code>if(stop&lt;start)step=-Math.abs(step)
</code></pre>

<p>Or more minimalistically:</p>

<pre><code>range=(b, e, step=1)=&gt;{
  if(!e){e=b;b=0}
  return Array.from(new Array(int((e-b)/step)), (_,i) =&gt; b&lt;e? b+i*step : b-i*step)
}
</code></pre>

<p>If you have huge ranges look at Paolo Moretti's generator approach</p>


blocks|key|1123244|text|没有本机方法。但是你可以用Array的filter方法来实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1123245|​|1123246|var+range+=+(array,+start,+end)+=>
++++++array.filter((element,+index)=>index>=start+&&+index+<=+end)


alert(+range(['a','h','e','l','l','o','s'],1,5)+)
//+['h','e','l','l','o']|code-block|syntax|javascript|1123247|1123248|entityMap^0|D|5|J|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|V|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|O|$]]

<p>There isn't a native method. But you can do it with <code>filter</code> method of <code>Array</code>.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var range = (array, start, end) =&gt;
      array.filter((element, index)=&gt;index&gt;=start &amp;&amp; index &lt;= end)


alert( range(['a','h','e','l','l','o','s'],1,5) )
// ['h','e','l','l','o']</code></pre>
</div>
</div>
</p>


blocks|key|908282|text|这里有一个很好的简单方法，在ES6中只使用数字(不知道它的速度比较)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908283|Array.prototype.map.call('+'.repeat(1+%2B+upper+-+lower),+(v,+i)+=>+i+%2B+lower)|code-block|syntax|javascript|908284|对于单个字符的范围，可以稍微修改一下：|908285|Array.prototype.map.call('+'.repeat(1+%2B+upper.codePointAt()+-+lower.codePointAt()),+(v,+i)+=>+String.fromCodePoint(i+%2B+lower.codePointAt()));|908286|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here's a nice short way to do it in ES6 with numbers only (don't know its speed compares):</p>

<pre><code>Array.prototype.map.call(' '.repeat(1 + upper - lower), (v, i) =&gt; i + lower)
</code></pre>

<p>For a range of single characters, you can slightly modify it:</p>

<pre><code>Array.prototype.map.call(' '.repeat(1 + upper.codePointAt() - lower.codePointAt()), (v, i) =&gt; String.fromCodePoint(i + lower.codePointAt()));
</code></pre>


blocks|key|1123354|text|对于字母，他是我用来生成字母范围的一个简单的普通JS解决方案。它仅用于生成大写或小写字母的数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123355|​|1123356|function+range(first,+last)+{
++++var+r+=+[],
++++++++i+=+first.charCodeAt(0);
++++
++++while(i+<=+last.charCodeAt(0))+{
++++++++r.push(String.fromCharCode(i%2B%2B));
++++}
++++
++++return+r;
}

console.dir(range("a",+"f"));
console.dir(range("G",+"Z"));|code-block|syntax|javascript|1123357|1123358|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>For letters, he's a simple vanilla JS solution I came up with to generate letter ranges.  It's intended to generate arrays of upper- or lowercase letters, only.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function range(first, last) {
    var r = [],
        i = first.charCodeAt(0);
    
    while(i &lt;= last.charCodeAt(0)) {
        r.push(String.fromCharCode(i++));
    }
    
    return r;
}

console.dir(range("a", "f"));
console.dir(range("G", "Z"));</code></pre>
</div>
</div>
</p>


blocks|key|1123403|text|可以创建一个大量使用ES6的相当简约的实现，如下所示，请特别注意Array.from()静态方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1123404|const+getRange+=+(start,+stop)+=>+Array.from(
++new+Array((stop+-+start)+%2B+1),
++(_,+i)+=>+i+%2B+start
);|code-block|syntax|javascript|1123405|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from^0|W|C|W|C|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

<p>A rather minimalistic implementation that heavily employs ES6 can be created as follows, drawing particular attention to the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from" rel="noreferrer"><code>Array.from()</code></a> static method:</p>

<pre><code>const getRange = (start, stop) =&gt; Array.from(
  new Array((stop - start) + 1),
  (_, i) =&gt; i + start
);
</code></pre>


blocks|key|908434|text|我想添加一个我认为是非常可调的版本，它非常快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908435|const+range+=+(start,+end)+=>+{
++++let+all+=+[];
++++if+(typeof+start+===+"string"+&&+typeof+end+===+"string")+{
++++++++//+Return+the+range+of+characters+using+utf-8+least+to+greatest
++++++++const+s+=+start.charCodeAt(0);
++++++++const+e+=+end.charCodeAt(0);
++++++++for+(let+i+=+s;+i+<=+e;+i%2B%2B)+{
++++++++++++all.push(String.fromCharCode(i));
++++++++}
++++}+else+if+(typeof+start+===+"number"+&&+typeof+end+===+"number")+{
++++++++//+Return+the+range+of+numbers+from+least+to+greatest
++++++++for(let+i+=+end;+i+>=+start;+i--)+{
++++++++++++all.push(i);
++++++++}
++++}+else+{
++++++++throw+new+Error("Did+not+supply+matching+types+number+or+string.");
++++}
++++return+all;
}
//+usage
const+aTod+=+range("a",+"d");|code-block|syntax|javascript|908436|如果你愿意，也可以打字|908437|const+range+=+(start:+string+%7C+number,+end:+string+%7C+number):+string[]+%7C+number[]+=>+{
++++const+all:+string[]+%7C+number[]+=+[];
++++if+(typeof+start+===+"string"+&&+typeof+end+===+"string")+{
++++++++const+s:+number+=+start.charCodeAt(0);
++++++++const+e:+number+=+end.charCodeAt(0);
++++++++for+(let+i+=+s;+i+<=+e;+i%2B%2B)+{
++++++++++++all.push(String.fromCharCode(i));
++++++++}
++++}+else+if+(typeof+start+===+"number"+&&+typeof+end+===+"number")+{
++++++++for+(let+i+=+end;+i+>=+start;+i--)+{
++++++++++++all.push(i);
++++++++}
++++}+else+{
++++++++throw+new+Error("Did+not+supply+matching+types+number+or+string.");
++++}
++++return+all;
}
//+Usage
const+negTenToten:+number[]+=+range(-10,+10)+as+number[];|908438|从其他答案中受到一些影响。用户现在已离开。|908439|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>I would like to add what I would think is a very adjustable version, which is very fast. </p>

<pre><code>const range = (start, end) =&gt; {
    let all = [];
    if (typeof start === "string" &amp;&amp; typeof end === "string") {
        // Return the range of characters using utf-8 least to greatest
        const s = start.charCodeAt(0);
        const e = end.charCodeAt(0);
        for (let i = s; i &lt;= e; i++) {
            all.push(String.fromCharCode(i));
        }
    } else if (typeof start === "number" &amp;&amp; typeof end === "number") {
        // Return the range of numbers from least to greatest
        for(let i = end; i &gt;= start; i--) {
            all.push(i);
        }
    } else {
        throw new Error("Did not supply matching types number or string.");
    }
    return all;
}
// usage
const aTod = range("a", "d");
</code></pre>

<p>Also Typescript if you would like</p>

<pre><code>const range = (start: string | number, end: string | number): string[] | number[] =&gt; {
    const all: string[] | number[] = [];
    if (typeof start === "string" &amp;&amp; typeof end === "string") {
        const s: number = start.charCodeAt(0);
        const e: number = end.charCodeAt(0);
        for (let i = s; i &lt;= e; i++) {
            all.push(String.fromCharCode(i));
        }
    } else if (typeof start === "number" &amp;&amp; typeof end === "number") {
        for (let i = end; i &gt;= start; i--) {
            all.push(i);
        }
    } else {
        throw new Error("Did not supply matching types number or string.");
    }
    return all;
}
// Usage
const negTenToten: number[] = range(-10, 10) as number[];
</code></pre>

<p>Made with some influence from other answers. User is gone now.</p>


blocks|key|1123486|text|我更喜欢下面的方式|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123487|​|1123488|var+range+=+function(x,+y)+{
++++return+Array(y+-+x%2B1).fill(x).map((a,+b)+=>+{return+a%2Bb}).filter(i+=>+i+>=+x);
};
console.log(range(3,+10));|code-block|syntax|javascript|1123489|1123490|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>I prefer the way below</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var range = function(x, y) {
    return Array(y - x+1).fill(x).map((a, b) =&gt; {return a+b}).filter(i =&gt; i &gt;= x);
};
console.log(range(3, 10));</code></pre>
</div>
</div>
</p>


blocks|key|1123535|text|..。更多的范围，使用一个生成器函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123536|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%2B%2B
++++}
++}
++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+%25+2)+?+acc.concat(c)+:+acc,+[]))

//+...+etc,+etc.|code-block|syntax|javascript|1123537|希望这是有用的。|1123538|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>... more range, using a generator function.</p>

<pre><code>function range(s, e, str){
  // create generator that handles numbers &amp; strings.
  function *gen(s, e, str){
    while(s &lt;= e){
      yield (!str) ? s : str[s]
      s++
    }
  }
  if (typeof s === 'string' &amp;&amp; !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'))
//=&gt; [ 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w' ]

console.log(range(7, 12))
//=&gt; [ 7, 8, 9, 10, 11, 12 ]

// first 'o' to first 't' of passed in string.
console.log(range('o', 't', "ssshhhooooouuut!!!!"))
// =&gt; [ 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 't' ]

// only lowercase args allowed here, but ...
console.log(range('m', 'v').map(v=&gt;v.toUpperCase()))
//=&gt; [ 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V' ]

// =&gt; and decreasing range ...
console.log(range('m', 'v').map(v=&gt;v.toUpperCase()).reverse())

// =&gt; ... and with a step
console.log(range('m', 'v')
          .map(v=&gt;v.toUpperCase())
          .reverse()
          .reduce((acc, c, i) =&gt; (i % 2) ? acc.concat(c) : acc, []))

// ... etc, etc.
</code></pre>

<p>Hope this is useful.</p>


blocks|key|1123564|text|这是我用来表示数字范围的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123565|const+rangeFrom0+=+end+=>+[...Array(end)].map((_,+index)+=>+index);|code-block|syntax|javascript|1123566|或|1123567|const+rangeExcEnd+=+(start,+step,+end)+=>+[...Array(end+-+start+%2B+1)]
+++.map((_,+index)+=>+index+%2B+start)
+++.filter(x+=>+x+%25+step+===+start+%25+step);|1123568|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>This is what I use for numbers ranges:</p>

<pre><code>const rangeFrom0 = end =&gt; [...Array(end)].map((_, index) =&gt; index);
</code></pre>

<p>or</p>

<pre><code>const rangeExcEnd = (start, step, end) =&gt; [...Array(end - start + 1)]
   .map((_, index) =&gt; index + start)
   .filter(x =&gt; x % step === start % step);
</code></pre>


blocks|key|1123616|text|这里有一个基于@benmcdonald和其他人的简单方法，虽然不止一行……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123617|​|1123618|let+K+=+[];
for+(i+=+'A'.charCodeAt(0);+i+<=+'Z'.charCodeAt(0);+i%2B%2B)+{
++K.push(String.fromCharCode(i))
};
console.log(K);|code-block|syntax|javascript|1123619|1123620|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Here is a simple approach based on @benmcdonald and others, more than one line though...</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let K = [];
for (i = 'A'.charCodeAt(0); i &lt;= 'Z'.charCodeAt(0); i++) {
  K.push(String.fromCharCode(i))
};
console.log(K);</code></pre>
</div>
</div>
</p>


blocks|key|908638|text|您还可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908639|const+range+=+Array.from(Array(size)).map((el,+idx)+=>+idx%2B1).slice(begin,+end);|code-block|syntax|javascript|908640|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>You can also do the following:</p>

<pre><code>const range = Array.from(Array(size)).map((el, idx) =&gt; idx+1).slice(begin, end);
</code></pre>


blocks|key|908684|text|所有的例子都没有测试，实现了一个可以产生递减值的步骤。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908685|export+function+range(start+=+0,+end+=+0,+step+=+1)+{
++++if+(start+===+end+%7C%7C+step+===+0)+{
++++++++return+[];
++++}

++++const+diff+=+Math.abs(end+-+start);
++++const+length+=+Math.ceil(diff+/+step);

++++return+start+>+end
++++++++?+Array.from({length},+(value,+key)+=>+start+-+key+*+step)
++++++++:+Array.from({length},+(value,+key)+=>+start+%2B+key+*+step);

}|code-block|syntax|javascript|908686|测试：|908687|import+range+from+'./range'

describe('Range',+()+=>+{
++++it('default',+()+=>+{
++++++++expect(range()).toMatchObject([]);
++++})

++++it('same+values',+()+=>+{
++++++++expect(range(1,1)).toMatchObject([]);
++++})

++++it('step=0',+()+=>+{
++++++++expect(range(0,1,0)).toMatchObject([]);
++++})

++++describe('step=1',+()+=>+{
++++++++it('normal',+()+=>+{
++++++++++++expect(range(6,12)).toMatchObject([6,+7,+8,+9,+10,+11]);
++++++++})

++++++++it('reversed',+()+=>+{
++++++++++++expect(range(12,6)).toMatchObject([12,+11,+10,+9,+8,+7]);
++++++++})
++++})

++++describe('step=5',+()+=>+{

++++++++it('start+0+end+60',+()+=>+{
++++++++++++expect(range(0,+60,+5)).toMatchObject([0,+5,+10,+15,+20,+25,+30,+35,+40,+45,+50,+55]);
++++++++})

++++++++it('reversed+start+60+end+-1',+()+=>+{
++++++++++++expect(range(55,+-1,+5)).toMatchObject([55,+50,+45,+40,+35,+30,+25,+20,+15,+10,+5,+0]);
++++++++})
++++})
})|908688|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>None of the examples had tests, implementation for step with an option to produce decreasing values.</p>

<pre><code>export function range(start = 0, end = 0, step = 1) {
    if (start === end || step === 0) {
        return [];
    }

    const diff = Math.abs(end - start);
    const length = Math.ceil(diff / step);

    return start &gt; end
        ? Array.from({length}, (value, key) =&gt; start - key * step)
        : Array.from({length}, (value, key) =&gt; start + key * step);

}
</code></pre>

<p>Tests:</p>

<pre><code>import range from './range'

describe('Range', () =&gt; {
    it('default', () =&gt; {
        expect(range()).toMatchObject([]);
    })

    it('same values', () =&gt; {
        expect(range(1,1)).toMatchObject([]);
    })

    it('step=0', () =&gt; {
        expect(range(0,1,0)).toMatchObject([]);
    })

    describe('step=1', () =&gt; {
        it('normal', () =&gt; {
            expect(range(6,12)).toMatchObject([6, 7, 8, 9, 10, 11]);
        })

        it('reversed', () =&gt; {
            expect(range(12,6)).toMatchObject([12, 11, 10, 9, 8, 7]);
        })
    })

    describe('step=5', () =&gt; {

        it('start 0 end 60', () =&gt; {
            expect(range(0, 60, 5)).toMatchObject([0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55]);
        })

        it('reversed start 60 end -1', () =&gt; {
            expect(range(55, -1, 5)).toMatchObject([55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0]);
        })
    })
})
</code></pre>


blocks|key|1123723|text|下面是一个range函数的定义，它的行为与Python的range类型完全相同，只是这个函数不是惰性的。把它变成一个生成器应该很容易。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1123724|range构造函数的参数必须是数字。如果省略step参数，则默认为1。如果省略start参数，则默认为0。如果step为零，则会引发错误。|1123725|range+=+(start,+stop,+step=1)+=>+{
++++if(step+===+0)+throw+new+Error("range()+arg+3+must+not+be+zero");

++++const+noStart+=+stop+==+null;
++++stop+=+noStart+?+start+:+stop;
++++start+=+noStart+?+0+:+start;
++++const+length+=+Math.ceil(((stop+-+start)+/+step));

++++return+Array.from({length},+(_,+i)+=>+(i+*+step)+%2B+start);
}

console.log(range(-10,+10,+2));
//output+[Array]+[-10,-8,-6,-4,-2,0,2,4,6,8]
console.log(range(10));
//+[Array]+[0,1,2,3,4,5,6,7,8,9]
console.log(3,+12);
//+[Array]+[3,4,5,6,7,8,9,10,11]|code-block|syntax|javascript|1123726|entityMap^0|S|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

<p>Here is a definition of a range function that behaves exactly like Python's <code>range</code> type except that this one is not lazy. It should be easy to turn it into a generator.</p>

<p>The arguments to the range constructor must be numbers. If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. If step is zero, an error is raised.</p>

<pre><code>range = (start, stop, step=1) =&gt; {
    if(step === 0) throw new Error("range() arg 3 must not be zero");

    const noStart = stop == null;
    stop = noStart ? start : stop;
    start = noStart ? 0 : start;
    const length = Math.ceil(((stop - start) / step));

    return Array.from({length}, (_, i) =&gt; (i * step) + start);
}

console.log(range(-10, 10, 2));
//output [Array] [-10,-8,-6,-4,-2,0,2,4,6,8]
console.log(range(10));
// [Array] [0,1,2,3,4,5,6,7,8,9]
console.log(3, 12);
// [Array] [3,4,5,6,7,8,9,10,11]
</code></pre>


blocks|key|908808|text|在边界内生成整数数组的递归解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908809|function+intSequence(start,+end,+n+=+start,+arr+=+[])+{
++return+(n+===+end)+?+arr.concat(n)
++++:+intSequence(start,+end,+start+<+end+?+n+%2B+1+:+n+-+1,+arr.concat(n));
}

$>+intSequence(1,+1)
<-+Array+[+1+]

$>+intSequence(1,+3)
<-+Array(3)+[+1,+2,+3+]

$>+intSequence(3,+-3)
<-+Array(7)+[+3,+2,+1,+0,+-1,+-2,+-3+]|code-block|syntax|javascript|908810|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>A recursive solution to generating integer array within bounds.</p>

<pre><code>function intSequence(start, end, n = start, arr = []) {
  return (n === end) ? arr.concat(n)
    : intSequence(start, end, start &lt; end ? n + 1 : n - 1, arr.concat(n));
}

$&gt; intSequence(1, 1)
&lt;- Array [ 1 ]

$&gt; intSequence(1, 3)
&lt;- Array(3) [ 1, 2, 3 ]

$&gt; intSequence(3, -3)
&lt;- Array(7) [ 3, 2, 1, 0, -1, -2, -3 ]
</code></pre>


blocks|key|908873|text|这个也是反向工作的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908874|const+range+=+(+a+,+b+)+=>+Array.from(+new+Array(+b+>+a+?+b+-+a+:+a+-+b+),+(+x,+i+)+=>+b+>+a+?+i+%2B+a+:+a+-+i+);

range(+-3,+2+);+//+[+-3,+-2,+-1,+0,+1+]
range(+1,+-4+);+//+[+1,+0,+-1,+-2,+-3+]|code-block|syntax|javascript|908875|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>This one works also in reverse.</p>

<pre><code>const range = ( a , b ) =&gt; Array.from( new Array( b &gt; a ? b - a : a - b ), ( x, i ) =&gt; b &gt; a ? i + a : a - i );

range( -3, 2 ); // [ -3, -2, -1, 0, 1 ]
range( 1, -4 ); // [ 1, 0, -1, -2, -3 ]
</code></pre>


blocks|key|1123887|text|我的codegolfing同事想出了这个(ES6)，包括：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123888|(s,f)=>[...Array(f-s%2B1)].map((e,i)=>i%2Bs)|code-block|syntax|javascript|1123889|不包含：|1123890|(s,f)=>[...Array(f-s)].map((e,i)=>i%2Bs)|1123891|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>My codegolfing coworker came up with this (ES6),
inclusive: </p>

<pre><code>(s,f)=&gt;[...Array(f-s+1)].map((e,i)=&gt;i+s)
</code></pre>

<p>non inclusive:</p>

<pre><code>(s,f)=&gt;[...Array(f-s)].map((e,i)=&gt;i+s)
</code></pre>


blocks|key|908956|text|您可以使用以下一行代码来保持简短和简单|type|unstyled|depth|inlineStyleRanges|entityRanges|data|908957|​|908958|var+start+=+4;
var+end+=+20;
console.log(Array(end+-+start+%2B+1).fill(start).map((x,+y)+=>+x+%2B+y));|code-block|syntax|javascript|908959|908960|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>You can use following one-liner to keep things short and simple</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var start = 4;
var end = 20;
console.log(Array(end - start + 1).fill(start).map((x, y) =&gt; x + y));</code></pre>
</div>
</div>
</p>


blocks|key|1123942|text|//+range()++++++++++++++0..10,+step=1
//+range(max)+++++++++++0..max,+step=1
//+range(min,max)+++++++min..max,+step=1
//+range(min,step,max)++min..max,+step=step
//+Use:
//+console.log(...range(3));
//+Array.from(range(5))
//+[...range(100)]
//+for+(const+v+of+range(1,10))+{+...+

function*+range(...args)+{
++++let+[min,+step,+max]+=+{
++++++++0:+[0,+1,+10],
++++++++1:+[0,+args[0]+>=+0+?+1+:+-1,+args[0]],
++++++++2:+[args[0],+args[1]+>=+args[0]+?+1+:+-1,+args[1]],
++++++++3:+args,
++++}[args.length]+%7C%7C+[];
++++if+(min+===+undefined)+throw+new+SyntaxError("Too+many+arguments");
++++let+x+=+min;
++++while+(step+>=+0+?+x+<+max+:+x+>+max)+{
++++++++yield+x;
++++++++x+%2B=+step
++++}
}
console.log(...range());++++++//+0+1+2+3+4+5+6+7+8+9
console.log(...range(3));+++++//+0+1+2
console.log(...range(2,+5));++//+2+3+4
console.log(...range(5,+2));++//+5+4+3
console.log(...range(3,+-3));+//+3+2+1+0+-1+-2
console.log(...range(-3,+3));+//+-3+-2+-1+0+1+2
console.log(...range(-5,+-2));//+-5+-4+-3
console.log(...range(-2,+-5));//+-2+-3+-4|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1123943|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// range()              0..10, step=1
// range(max)           0..max, step=1
// range(min,max)       min..max, step=1
// range(min,step,max)  min..max, step=step
// Use:
// console.log(...range(3));
// Array.from(range(5))
// [...range(100)]
// for (const v of range(1,10)) { ... 

function* range(...args) {
    let [min, step, max] = {
        0: [0, 1, 10],
        1: [0, args[0] &gt;= 0 ? 1 : -1, args[0]],
        2: [args[0], args[1] &gt;= args[0] ? 1 : -1, args[1]],
        3: args,
    }[args.length] || [];
    if (min === undefined) throw new SyntaxError("Too many arguments");
    let x = min;
    while (step &gt;= 0 ? x &lt; max : x &gt; max) {
        yield x;
        x += step
    }
}
console.log(...range());      // 0 1 2 3 4 5 6 7 8 9
console.log(...range(3));     // 0 1 2
console.log(...range(2, 5));  // 2 3 4
console.log(...range(5, 2));  // 5 4 3
console.log(...range(3, -3)); // 3 2 1 0 -1 -2
console.log(...range(-3, 3)); // -3 -2 -1 0 1 2
console.log(...range(-5, -2));// -5 -4 -3
console.log(...range(-2, -5));// -2 -3 -4
</code></pre>


blocks|key|1123994|text|具有定义的硬int的范围有一大堆答案，但如果您不知道该步骤，而您希望在这两个步骤之间有许多步骤，该怎么办？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123995|我写这段代码就是为了做到这一点。这是不言而喻的。|1123996|const+stepScale+=+(min,+max,+numberOfSteps)+=>+{
++const+_numberOfSteps+=+numberOfSteps+-+1
++const+scaleBy+=+(max+-+min)+/+_numberOfSteps

++const+arr+=+[]
++for+(let+i+=+0;+i+<=+_numberOfSteps;+i+%2B=+1)+{
++++arr.push(min+%2B+scaleBy+*+i)
++}
++return+arr
}

export+default+stepScale|code-block|syntax|javascript|1123997|stepScale(5,+10,+4)
//+[5,+6.666666666666667,+8.333333333333334,+10]|1123998|对于https://npm.im/@universalstandard/step-scale上的npm|offset|length|1123999|entityMap|0|LINK|mutability|MUTABLE|url|https://npm.im/@universalstandard/step-scale^0|0|0|0|0|2|18|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

<p>A range with a defined hard int has a ton of answers, but what if you don't know that step and you want a number of steps in-between instead?</p>

<p>I wrote this code to do that. It's pretty self-explanatory. </p>

<pre class="lang-js prettyprint-override"><code>const stepScale = (min, max, numberOfSteps) =&gt; {
  const _numberOfSteps = numberOfSteps - 1
  const scaleBy = (max - min) / _numberOfSteps

  const arr = []
  for (let i = 0; i &lt;= _numberOfSteps; i += 1) {
    arr.push(min + scaleBy * i)
  }
  return arr
}

export default stepScale
</code></pre>

<pre class="lang-js prettyprint-override"><code>stepScale(5, 10, 4)
// [5, 6.666666666666667, 8.333333333333334, 10]
</code></pre>

<p>For npm at <a href="https://npm.im/@universalstandard/step-scale" rel="nofollow noreferrer">https://npm.im/@universalstandard/step-scale</a></p>


blocks|key|1124004|text|保持简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124005|//+Generator
function*+iter(a,+b,+step+=+1)+{
++for+(let+i+=+b+?+a+:+0;+i+<+(b+%7C%7C+a);+i+%2B=+step)+{
++++yield+i
++}
}

const+range+=+(a,+b,+step+=+1)+=>
++typeof+a+===+'string'
++++?+[...iter(a.charCodeAt(),+b.charCodeAt()+%2B+1)].map(n+=>+String.fromCharCode(n))
++++:+[...iter(a,+b,+step)]

range(4)+//+[0,+1,+2,+3]
range(1,+4)+//+[1,+2,+3]
range(2,+20,+3)+//+[2,+5,+8,+11,+14,+17]
range('A',+'C')+//+['A',+'B',+'C']|code-block|syntax|javascript|1124006|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Keeping it simple:</p>

<pre><code>// Generator
function* iter(a, b, step = 1) {
  for (let i = b ? a : 0; i &lt; (b || a); i += step) {
    yield i
  }
}

const range = (a, b, step = 1) =&gt;
  typeof a === 'string'
    ? [...iter(a.charCodeAt(), b.charCodeAt() + 1)].map(n =&gt; String.fromCharCode(n))
    : [...iter(a, b, step)]

range(4) // [0, 1, 2, 3]
range(1, 4) // [1, 2, 3]
range(2, 20, 3) // [2, 5, 8, 11, 14, 17]
range('A', 'C') // ['A', 'B', 'C']
</code></pre>


blocks|key|1124052|text|为了在任何一个给定的数字可能更大的情况下工作，我写了以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124053|function+getRange(start,+end)+{
++return+Array.from({
++++length:+1+%2B+Math.abs(end+-+start)
++},+(_,+i)+=>+end+>+start+?+start+%2B+i+:+start+-+i);
}|code-block|syntax|javascript|1124054|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>In order to work where either given number could be larger I wrote this:</p>

<pre><code>function getRange(start, end) {
  return Array.from({
    length: 1 + Math.abs(end - start)
  }, (_, i) =&gt; end &gt; start ? start + i : start - i);
}
</code></pre>


blocks|key|909115|text|Pythonic风格的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|909116|range+=+(start,+end,+step)+=>+{
let+arr+=+[]
for(let+n=start;n<end;n%2B=(step%7C%7C1))+arr.push(n)
return+arr;
}|code-block|syntax|javascript|909117|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Pythonic styled way:</p>

<pre class="lang-js prettyprint-override"><code>range = (start, end, step) =&gt; {
let arr = []
for(let n=start;n&lt;end;n+=(step||1)) arr.push(n)
return arr;
}
</code></pre>


blocks|key|1124105|text|Array.from(Array((m+-+n+%2B+1)),+(v,+i)+=>+n+%2B+i);+//+m+>+n+and+both+of+them+are+integers.|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1124106|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Array.from(Array((m - n + 1)), (v, i) =&gt; n + i); // m &gt; n and both of them are integers.
</code></pre>


blocks|key|1124190|text|https://stackoverflow.com/a/49577331/8784402|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1124191|使用增量/步骤|1124192|最小和单行|1124193|[...Array(N)].map((_,+i)+=>+from+%2B+i+*+step);|code-block|syntax|javascript|1124194|示例和其他替代方案|1124195|[...Array(10)].map((_,+i)+=>+4+%2B+i+*+2);
//=>+[4,+6,+8,+10,+12,+14,+16,+18,+20,+22]

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

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

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

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

Array(10).fill().map((_,+i)+=>+4+%2B+i+*+-2);
//=>+[4,+2,+0,+-2,+-4,+-6,+-8,+-10,+-12,+-14]|1124196|Range函数|1124197|const+range+=+(from,+to,+step)+=>
++[...Array(Math.floor((to+-+from)+/+step)+%2B+1)].map((_,+i)+=>+from+%2B+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)+%2B+1)].map((_,+i)+=>+from+%2B+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]|1124198|作为迭代器|1124199|class+Range+{
++constructor(total+=+0,+step+=+1,+from+=+0)+{
++++this[Symbol.iterator]+=+function*+()+{
++++++for+(let+i+=+0;+i+<+total;+yield+from+%2B+i%2B%2B+*+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|1124200|仅作为生成器|1124201|const+Range+=+function*+(total+=+0,+step+=+1,+from+=+0)+{
++for+(let+i+=+0;+i+<+total;+yield+from+%2B+i%2B%2B+*+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
//+...|1124202|从-到，步骤/增量|1124203|使用迭代器|1124204|class+Range2+{
++constructor(to+=+0,+step+=+1,+from+=+0)+{
++++this[Symbol.iterator]+=+function*+()+{
++++++let+i+=+0,
++++++++length+=+Math.floor((to+-+from)+/+step)+%2B+1;
++++++while+(i+<+length)+yield+from+%2B+i%2B%2B+*+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]|1124205|使用生成器|1124206|const+Range2+=+function*+(to+=+0,+step+=+1,+from+=+0)+{
++let+i+=+0,
++++length+=+Math.floor((to+-+from)+/+step)+%2B+1;
++while+(i+<+length)+yield+from+%2B+i%2B%2B+*+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|1124207|对于Typescript|1124208|class+_Array<T>+extends+Array<T>+{
++static+range(from:+number,+to:+number,+step:+number):+number[]+{
++++return+Array.from(Array(Math.floor((to+-+from)+/+step)+%2B+1)).map(
++++++(v,+k)+=>+from+%2B+k+*+step
++++);
++}
}
_Array.range(0,+9,+1);|1124209|https://stackoverflow.com/a/64599169/8784402|1124210|使用一行程序生成字符列表|1124211|​|1124212|const+charList+=+(a,z,d=1)=>(a=a.charCodeAt(),z=z.charCodeAt(),[...Array(Math.floor((z-a)/d)%2B1)].map((_,i)=>String.fromCharCode(a%2Bi*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('А',+'Я'));|1124213|1124214|对于TypeScript|1124215|const+charList+=+(p:+string,+q:+string,+d+=+1)+=>+{
++const+a+=+p.charCodeAt(0),
++++z+=+q.charCodeAt(0);
++return+[...Array(Math.floor((z+-+a)+/+d)+%2B+1)].map((_,+i)+=>
++++String.fromCharCode(a+%2B+i+*+d)
++);
};|1124216|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|18|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|18|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|21|8|@]|9|@$A|22|B|23|1|24]]|C|$]]|$1|D|3|E|5|6|7|25|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|26|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|27|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|28|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|29|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|2A|8|@]|9|@]|C|$]]|$1|S|3|T|5|J|7|2B|8|@]|9|@]|C|$K|L]]|$1|U|3|V|5|6|7|2C|8|@]|9|@]|C|$]]|$1|W|3|X|5|J|7|2D|8|@]|9|@]|C|$K|L]]|$1|Y|3|Z|5|6|7|2E|8|@]|9|@]|C|$]]|$1|10|3|11|5|J|7|2F|8|@]|9|@]|C|$K|L]]|$1|12|3|13|5|6|7|2G|8|@]|9|@]|C|$]]|$1|14|3|15|5|6|7|2H|8|@]|9|@]|C|$]]|$1|16|3|17|5|J|7|2I|8|@]|9|@]|C|$K|L]]|$1|18|3|19|5|6|7|2J|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|J|7|2K|8|@]|9|@]|C|$K|L]]|$1|1C|3|1D|5|6|7|2L|8|@]|9|@]|C|$]]|$1|1E|3|1F|5|J|7|2M|8|@]|9|@]|C|$K|L]]|$1|1G|3|1H|5|6|7|2N|8|@]|9|@$A|2O|B|2P|1|2Q]]|C|$]]|$1|1I|3|1J|5|6|7|2R|8|@]|9|@]|C|$]]|$1|1K|3|1L|5|6|7|2S|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|J|7|2T|8|@]|9|@]|C|$K|L]]|$1|1O|3|1L|5|6|7|2U|8|@]|9|@]|C|$]]|$1|1P|3|1Q|5|6|7|2V|8|@]|9|@]|C|$]]|$1|1R|3|1S|5|J|7|2W|8|@]|9|@]|C|$K|L]]|$1|1T|3|-4|5|6|7|2X|8|@]|9|@]|C|$]]]|1U|$1V|$5|1W|1X|1Y|C|$1Z|4]]|20|$5|1W|1X|1Y|C|$1Z|1H]]]]

<p><a href="https://stackoverflow.com/a/49577331/8784402">https://stackoverflow.com/a/49577331/8784402</a></p>
<h2>With Delta/Step</h2>
smallest and one-liner
<pre class="lang-js prettyprint-override"><code>[...Array(N)].map((_, i) =&gt; from + i * step);
</code></pre>
<p>Examples and other alternatives</p>
<pre class="lang-js prettyprint-override"><code>[...Array(10)].map((_, i) =&gt; 4 + i * 2);
//=&gt; [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

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

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

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

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

Array(10).fill().map((_, i) =&gt; 4 + i * -2);
//=&gt; [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]
</code></pre>
Range Function
<pre class="lang-js prettyprint-override"><code>const range = (from, to, step) =&gt;
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) =&gt; from + i * step);

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

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

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

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

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

Array.range(3, 0, -1);
//=&gt; [3, 2, 1, 0]
</code></pre>
As Iterators
<pre class="lang-js prettyprint-override"><code>class Range {
  constructor(total = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      for (let i = 0; i &lt; total; yield from + i++ * step) {}
    };
  }
}

[...new Range(5)]; // Five Elements
//=&gt; [0, 1, 2, 3, 4]
[...new Range(5, 2)]; // Five Elements With Step 2
//=&gt; [0, 2, 4, 6, 8]
[...new Range(5, -2, 10)]; // Five Elements With Step -2 From 10
//=&gt;[10, 8, 6, 4, 2]
[...new Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=&gt; [-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
</code></pre>
As Generators Only
<pre class="lang-js prettyprint-override"><code>const Range = function* (total = 0, step = 1, from = 0) {
  for (let i = 0; i &lt; total; yield from + i++ * step) {}
};

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

[...Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=&gt; [-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;
//=&gt; 0
number0toInf.next().value;
//=&gt; 1
// ...
</code></pre>
<h3>From-To with steps/delta</h3>
using iterators
<pre class="lang-js prettyprint-override"><code>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 &lt; length) yield from + i++ * step;
    };
  }
}
[...new Range2(5)]; // First 5 Whole Numbers
//=&gt; [0, 1, 2, 3, 4, 5]

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

[...new Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=&gt; [10, 8, 6]
</code></pre>
using Generators
<pre class="lang-js prettyprint-override"><code>const Range2 = function* (to = 0, step = 1, from = 0) {
  let i = 0,
    length = Math.floor((to - from) / step) + 1;
  while (i &lt; length) yield from + i++ * step;
};

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

let even4to10 = Range2(10, 2, 4);
even4to10.next().value;
//=&gt; 4
even4to10.next().value;
//=&gt; 6
even4to10.next().value;
//=&gt; 8
even4to10.next().value;
//=&gt; 10
even4to10.next().value;
//=&gt; undefined
</code></pre>
<h3>For Typescript</h3>
<pre><code>class _Array&lt;T&gt; extends Array&lt;T&gt; {
  static range(from: number, to: number, step: number): number[] {
    return Array.from(Array(Math.floor((to - from) / step) + 1)).map(
      (v, k) =&gt; from + k * step
    );
  }
}
_Array.range(0, 9, 1);
</code></pre>
<p><a href="https://stackoverflow.com/a/64599169/8784402">https://stackoverflow.com/a/64599169/8784402</a></p>
<h3>Generate Character List with one-liner</h3>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const charList = (a,z,d=1)=&gt;(a=a.charCodeAt(),z=z.charCodeAt(),[...Array(Math.floor((z-a)/d)+1)].map((_,i)=&gt;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('А', 'Я'));</code></pre>
</div>
</div>
</p>
For TypeScript
<pre><code>const charList = (p: string, q: string, d = 1) =&gt; {
  const a = p.charCodeAt(0),
    z = q.charCodeAt(0);
  return [...Array(Math.floor((z - a) / d) + 1)].map((_, i) =&gt;
    String.fromCharCode(a + i * d)
  );
};
</code></pre>


blocks|key|909229|text|我个人最喜欢的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|909230|const+range+=+(start,+end)+=>+new+Array(end-start%2B1).fill().map((el,+ind)+=>+ind+%2B+start);|code-block|syntax|javascript|909231|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>My personal favorite:</p>
<pre class="lang-js prettyprint-override"><code>const range = (start, end) =&gt; new Array(end-start+1).fill().map((el, ind) =&gt; ind + start);
</code></pre>


blocks|key|1124329|text|使用这个。它创建一个具有给定数量的值(未定义)的数组，在下面的示例中有100个索引，但它并不相关，因为在这里您只需要键。它在数组中使用100+%2B+1，因为数组总是基于0索引。因此，如果要生成100个值，索引将从0开始；因此，最后一个值始终是99，而不是100。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124330|​|1124331|range(2,+100);

function+range(start,+end)+{
++++console.log([...Array(end+%2B+1).keys()].filter(value+=>+end+>=+value+&&+start+<=+value+));
}|code-block|syntax|javascript|1124332|1124333|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Use this. It creates an array with given amount of values (undefined), in the following example there are 100 indexes, but it is not relevant as here you need only the keys. It uses in the array, 100 + 1, because the arrays are always 0 index based. So if it's given 100 values to generate, the index starts from 0; hence the last value is always 99 not 100.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>range(2, 100);

function range(start, end) {
    console.log([...Array(end + 1).keys()].filter(value =&gt; end &gt;= value &amp;&amp; start &lt;= value ));
}</code></pre>
</div>
</div>
</p>


blocks|key|1124365|text|您可以创建自己的es6范围版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124366|​|1124367|const+range+=+(min,+max)+=>+{
++const+arr+=+Array(max+-+min+%2B+1)
++++.fill(0)
++++.map((_,+i)+=>+i+%2B+min);
++return+arr;
}

console.log(range(0,5));

console.log(range(2,8))|code-block|syntax|javascript|1124368|1124369|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>You can create your own es6 range version</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="true">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const range = (min, max) =&gt; {
  const arr = Array(max - min + 1)
    .fill(0)
    .map((_, i) =&gt; i + min);
  return arr;
}

console.log(range(0,5));

console.log(range(2,8))</code></pre>
</div>
</div>
</p>


blocks|key|1124433|text|对于行为类似python+range()函数的函数，请使用以下命令：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1124434|function+range(min=0,+max=null){
++++if(max+===+null){
++++++++max=min;
++++++++min=0;
++++}
++++var+rg=[...Array(max).keys()];
++++return+rg.slice(min,max);
}+++|code-block|syntax|javascript|1124435|entityMap^0|D|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<p>For function that behaves like python <code>range()</code> function, use this:</p>
<pre class="lang-js prettyprint-override"><code>function range(min=0, max=null){
    if(max === null){
        max=min;
        min=0;
    }
    var rg=[...Array(max).keys()];
    return rg.slice(min,max);
}   

</code></pre>


blocks|key|1124492|text|循环遍历一个介于0和长度(以Vue表示)之间的数字范围：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124493|<div+v-for="index+in+range"+/>

computed:+{
+++range+()+{
++++++++let+x+=+[];

++++++++for+(let+i+=+0;+i+<+this.myLength;+i%2B%2B)
++++++++{
++++++++++++x.push(i);
++++++++}

++++++++return+x;
++++}
}|code-block|syntax|javascript|1124494|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Loop over a range of numbers between 0 and your Length in Vue:</p>
<pre><code>
&lt;div v-for=&quot;index in range&quot; /&gt;

computed: {
   range () {
        let x = [];

        for (let i = 0; i &lt; this.myLength; i++)
        {
            x.push(i);
        }

        return x;
    }
}
    
</code></pre>


blocks|key|1124584|text|您还可以使用生成器来生成序列。不同之处在于序列中的每个值都是延迟加载的。扩展运算符和for+of对结果起作用。星号符号使函数成为生成器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124585|const+range+=+function*(from,to)+{+ +
++++for(let+i+=+from;+i+<=+to;+i%2B%2B)+yield+I;+ +
};+ +

[...range(3,5)]//+=>+[3,+4,+5]|code-block|syntax|javascript|1124586|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>You can also use a generator to produce the sequence.
The difference is that each value in the sequence is lazy loaded. spread operator and for of works for the result.
The asterisk symbols makes the function to be a generator.</p>
<pre><code>const range = function*(from,to) {   
    for(let i = from; i &lt;= to; i++) yield I;   
};   

[...range(3,5)]// =&gt; [3, 4, 5]
</code></pre>


blocks|key|909582|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|909583|function+range(firstNum,+lastNum)+{
++let+rangeList+=+[];
++if+(firstNum+>+lastNum)+{
++++return+console.error("First+number+cannot+be+bigger+than+last+number");
++}

++let+counter+=+firstNum;
++while(counter+<=+lastNum)+{
++++rangeList.push(counter);
++++counter%2B%2B;
++}

++return+rangeList;
}|code-block|syntax|javascript|909584|909585|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function range(firstNum, lastNum) {
  let rangeList = [];
  if (firstNum &gt; lastNum) {
    return console.error("First number cannot be bigger than last number");
  }

  let counter = firstNum;
  while(counter &lt;= lastNum) {
    rangeList.push(counter);
    counter++;
  }

  return rangeList;
}</code></pre>
</div>
</div>
</p>


blocks|key|1124608|text|(from,+to)+=>+[...Array(to+-+from)].map((_,i)=>+i+%2B+from)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1124609|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>(from, to) =&gt; [...Array(to - from)].map((_,i)=&gt; i + from)
</code></pre>


blocks|key|1124672|text|下面是实现您自己的可迭代范围函数的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124673|​|1124674|//+implementing+range
function+range(start,+end){
++++return+{
++++++from:+start,
++++++to:+end,

++++++[Symbol.iterator]()+{+
++++++++this.current+=+this.from;
++++++++return+this;
++++++},

++++++next()+{+
++++++++if+(this.current+<=+this.to)+{
++++++++++return+{+done:+false,+value:+this.current%2B%2B+};
++++++++}+else+{
++++++++++return+{+done:+true+};
++++++++}
++++++}
++++};

}

//+iterate+over+each+value
for+(let+num+of+range(1,5))+{
++console.log(num);+//+1,+2,+3,+4,+5
}|code-block|syntax|javascript|1124675|1124676|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Here is the way to implment your own iterable range function.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>// implementing range
function range(start, end){
    return {
      from: start,
      to: end,

      [Symbol.iterator]() { 
        this.current = this.from;
        return this;
      },

      next() { 
        if (this.current &lt;= this.to) {
          return { done: false, value: this.current++ };
        } else {
          return { done: true };
        }
      }
    };

}

// iterate over each value
for (let num of range(1,5)) {
  console.log(num); // 1, 2, 3, 4, 5
}</code></pre>
</div>
</div>
</p>


blocks|key|1124751|text|已经给出了非常好的答案，但我没有看到完全使用ES6迭代器来实现range的完整实现，所以这里是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1124752|/**
+*+inspired+by+Python's+built-in+range+utility+function
+*+implemented+using+ES6+Iterable,+Iterator++protolols+(interfaces)
+*/
class+Range+{
++constructor(...args)+{
++++this.start+=+args.length+<=+1+?+0+:+args[0];
++++this.end+=+args.length+<=+1+?+args[0]+%7C%7C+0+:+args[1];
++++this.step+=+args.length+<=+2+?+1+:+args[2];
++}

++[Symbol.iterator]()+{
++++return+this;
++}

++next()+{
++++if+(this.end+>+this.start)+{
++++++const+result+=+{+done:+false,+value:+this.start+};
++++++this.start+=+this.start+%2B+this.step;
++++++return+result;
++++}+else+return+{+done:+true,+value:+undefined+};
++}
}

/**
+*+Symbol.iterator+is+part+of+the+couple+of+inbuilt+symbols
+*+available+in+JavaScript.+It+allows+for+hooking+into+the
+*+inbuilt+for+of+iteration+mechanism.+This+is+why+the
+*+Symbol.iterator+comes+into+play+when+talking+about
+*+iterables+and+iterators+in+JavaScript.
+*/

function+range(...args)+{
++return+new+Range(...args);
}

console.log([...range(4)]);++++++++//+[0,+1,+2,+3]
console.log([...range(2,+5)]);+++++//+[2,+3,+4]
console.log([...range(1,+10,+3)]);+//+[1,+4,+7]|code-block|syntax|javascript|1124753|entityMap^0|V|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<p>There is already very good answers given, but I did not see complete usage of ES6 iterator utilized to achieve full implementation of <code>range</code>, so here it is:</p>
<pre><code>/**
 * inspired by Python's built-in range utility function
 * implemented using ES6 Iterable, Iterator  protolols (interfaces)
 */
class Range {
  constructor(...args) {
    this.start = args.length &lt;= 1 ? 0 : args[0];
    this.end = args.length &lt;= 1 ? args[0] || 0 : args[1];
    this.step = args.length &lt;= 2 ? 1 : args[2];
  }

  [Symbol.iterator]() {
    return this;
  }

  next() {
    if (this.end &gt; this.start) {
      const result = { done: false, value: this.start };
      this.start = this.start + this.step;
      return result;
    } else return { done: true, value: undefined };
  }
}

/**
 * Symbol.iterator is part of the couple of inbuilt symbols
 * available in JavaScript. It allows for hooking into the
 * inbuilt for of iteration mechanism. This is why the
 * Symbol.iterator comes into play when talking about
 * iterables and iterators in JavaScript.
 */

function range(...args) {
  return new Range(...args);
}

console.log([...range(4)]);        // [0, 1, 2, 3]
console.log([...range(2, 5)]);     // [2, 3, 4]
console.log([...range(1, 10, 3)]); // [1, 4, 7]
</code></pre>


blocks|key|1124779|text|我的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1124780|export+function+stringRange(a:+string,+b:+string)+{
++++let+arr+=+[a+%2B+''];

++++const+startPrefix+=+a.match(/([\D])%2B/g);
++++const+endPrefix+=+b.match(/([\D])%2B/g);

++++if+((startPrefix+%7C%7C+endPrefix)+&&+(Array.isArray(startPrefix)+&&+startPrefix[0])+!==+(Array.isArray(endPrefix)+&&+endPrefix[0]))+{
++++++++throw+new+Error('Series+number+does+not+match');
++++}

++++const+startNum+=+a.match(/([\d])%2B/g);
++++const+endNum+=+b.match(/([\d])%2B/g);

++++if+(!startNum+%7C%7C+!endNum)+{
++++++++throw+new+Error('Range+is+not+valid');
++++}

++++let+start+=+parseInt(startNum[0],+10);
++++let+end+=+parseInt(endNum[0],+10);

++++if+(start+>+end)+{
++++++++throw+new+Error('Ending+value+should+be+lessesr+that+starting+value');
++++}

++++while+(start+!==+end)+{
++++++++start%2B%2B;
++++++++arr.push(startPrefix+?+startPrefix[0]+%2B+(start+%2B+'').padStart(startNum[0].length,+'0')+:+start+%2B+'');

++++}

++++return+arr;
}|code-block|syntax|javascript|1124781|示例结果|1124782|//+console.log(range('0',+'10'));
//+console.log(range('10',+'10'));+
//+console.log(range('10',+'20'));
//+console.log(range('10',+'20000'));
//+console.log(range('ABC10',+'ABC23'));
//+console.log(range('ABC10',+'ABC2300'));
//+console.log(range('ABC10',+'ABC09'));+-->+Failure+case
//+console.log(range('10',+'ABC23'));+-->+Failure+case
//+console.log(range('ABC10',+'23'));+-->+Failure+case|1124783|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>My implementation</p>
<pre class="lang-js prettyprint-override"><code>export function stringRange(a: string, b: string) {
    let arr = [a + ''];

    const startPrefix = a.match(/([\D])+/g);
    const endPrefix = b.match(/([\D])+/g);

    if ((startPrefix || endPrefix) &amp;&amp; (Array.isArray(startPrefix) &amp;&amp; startPrefix[0]) !== (Array.isArray(endPrefix) &amp;&amp; endPrefix[0])) {
        throw new Error('Series number does not match');
    }

    const startNum = a.match(/([\d])+/g);
    const endNum = b.match(/([\d])+/g);

    if (!startNum || !endNum) {
        throw new Error('Range is not valid');
    }

    let start = parseInt(startNum[0], 10);
    let end = parseInt(endNum[0], 10);

    if (start &gt; end) {
        throw new Error('Ending value should be lessesr that starting value');
    }

    while (start !== end) {
        start++;
        arr.push(startPrefix ? startPrefix[0] + (start + '').padStart(startNum[0].length, '0') : start + '');

    }

    return arr;
}

</code></pre>
<p>Sample Result</p>
<pre class="lang-sh prettyprint-override"><code>// console.log(range('0', '10'));
// console.log(range('10', '10')); 
// console.log(range('10', '20'));
// console.log(range('10', '20000'));
// console.log(range('ABC10', 'ABC23'));
// console.log(range('ABC10', 'ABC2300'));
// console.log(range('ABC10', 'ABC09')); --&gt; Failure case
// console.log(range('10', 'ABC23')); --&gt; Failure case
// console.log(range('ABC10', '23')); --&gt; Failure case
</code></pre>


<p>In PHP, you can do...</p>

<pre><code>range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")
</code></pre>

<p>That is, there is a function that lets you get a range of numbers or characters by passing the upper and lower bounds.</p>

<p>Is there anything built-in to JavaScript natively for this? If not, how would I implement it?</p>


Does JavaScript have a method like "range()" to generate a range within the supplied bounds?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

在PHP中，您可以...range(1, 3); // Array(1, 2, 3)range("A", "C"); // Array("A", "B", "C")也就是说，有一个函数可以让您通过传递上限和下限来获取一系列数字或字符。JavaScript本身有什么内置的功能吗？如果不是，我该如何实现它？

问JavaScript是否有像" range ()“这样的方法来在提供的范围内生成范围？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript是否有像" range ()“这样的方法来在提供的范围内生成范围？EN