在PHP中，您可以。。。
range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")
也就是说，有一个函数可以通过传递上下限来获得一系列数字或字符。
JavaScript本机是否有内置的功能？如果没有，我将如何实施？
当前回答
function check(){
var correct=true;
for(var i=0; i<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 && (step && end)!=0){
for(var i=start; i<=end; i+=step)
document.write(i+" "); }
else document.write("Not Correct Data"); }
其他回答
这里是一个范围函数的定义，它的行为与Python的范围类型完全相同，只是这个函数不是懒惰的。把它变成发电机应该很容易。
范围构造函数的参数必须是数字。如果省略step参数，则默认为1。如果省略了start参数，则默认为0。如果步骤为零，则会引发错误。
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) + 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]
对一些不同的范围函数进行了研究。检查执行这些函数的不同方法的jsperf比较。当然不是一个完美或详尽的列表，但应该有帮助：）
获胜者是。。。
function range(lowEnd,highEnd){
var arr = [],
c = highEnd - lowEnd + 1;
while ( c-- ) {
arr[c] = highEnd--
}
return arr;
}
range(0,31);
从技术上讲，它不是firefox上最快的，但铬合金上的疯狂速度差（imho）弥补了这一点。
还有一个有趣的观察是，与firefox相比，chrome使用这些阵列功能的速度要快得多。Chrome速度至少快4或5倍。
我最喜欢的是生成器generateRange，它带有另一个运行生成器的函数getRange。与许多其他解决方案相比，这样做的一个优点是不需要的阵列不会多次创建。
function* generateRange(start, end, step = 1) {
let current = start;
while (start < end ? current <= end : current >= end) {
yield current;
current = start < end ? current + step : current - step;
}
}
function getRange(start, end, step = 1) {
return [...generateRange(start, end, step)];
}
console.log(getRange(0, 5)) // [ 0, 1, 2, 3, 4, 5 ]
console.log(getRange(10, 0, 2)) // [ 10, 8, 6, 4, 2, 0 ]
(from, to) => [...Array(to - from)].map((_,i)=> i + from)
我的代码高尔夫同事想出了这个（ES6），包容的：
(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)
非包容性：
(s,f)=>[...Array(f-s)].map((e,i)=>i+s)
