ฟังก์ชัน JavaScript คล้ายกับ Python range ()

มีฟังก์ชันใน JavaScript คล้ายกับ Python range()หรือไม่?

ฉันคิดว่าน่าจะมีวิธีที่ดีกว่าการเขียนบรรทัดต่อไปนี้ทุกครั้ง:

array = new Array();
for (i = 0; i < specified_len; i++) {
    array[i] = i;
}

ไม่ไม่มีเลย แต่คุณสามารถสร้างได้

การใช้งาน JavaScript ของ Python range()

พยายามเลียนแบบวิธีการทำงานใน Pythonฉันจะสร้างฟังก์ชันที่คล้ายกับสิ่งนี้:

function range(start, stop, step) {
    if (typeof stop == 'undefined') {
        // one param defined
        stop = start;
        start = 0;
    }

    if (typeof step == 'undefined') {
        step = 1;
    }

    if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
        return [];
    }

    var result = [];
    for (var i = start; step > 0 ? i < stop : i > stop; i += step) {
        result.push(i);
    }

    return result;
};

ดูjsfiddle นี้เพื่อพิสูจน์

การเปรียบเทียบระหว่างrange()ใน JavaScript และ Python

มันทำงานในลักษณะต่อไปนี้:

• range(4)ผลตอบแทน[0, 1, 2, 3],
• range(3,6)ผลตอบแทน[3, 4, 5],
• range(0,10,2)ผลตอบแทน[0, 2, 4, 6, 8],
• range(10,0,-1)ผลตอบแทน[10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
• range(8,2,-2)ผลตอบแทน[8, 6, 4],
• range(8,2)ผลตอบแทน[],
• range(8,2,2)ผลตอบแทน[],
• range(1,5,-1)ผลตอบแทน[],
• range(1,5,-2)ผลตอบแทน[],

และคู่ของ Python ทำงานในลักษณะเดียวกัน (อย่างน้อยในกรณีที่กล่าวถึง):

>>> range(4)
[0, 1, 2, 3]
>>> range(3,6)
[3, 4, 5]
>>> range(0,10,2)
[0, 2, 4, 6, 8]
>>> range(10,0,-1)
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> range(8,2,-2)
[8, 6, 4]
>>> range(8,2)
[]
>>> range(8,2,2)
[]
>>> range(1,5,-1)
[]
>>> range(1,5,-2)
[]

ดังนั้นหากคุณต้องการฟังก์ชั่นในการทำงานคล้ายกับ Python range()คุณสามารถใช้โซลูชันที่กล่าวถึงข้างต้นได้

สำหรับช่วงที่ง่ายมากใน ES6:

let range = n => Array.from(Array(n).keys())

จากความคิดเห็นของ bigOmegaสามารถย่อให้สั้นลงได้โดยใช้ไวยากรณ์ของ Spread :

let range = n => [...Array(n).keys()]

2018: คำตอบนี้ยังคงได้รับคะแนนโหวตดังนั้นนี่คือการอัปเดต โค้ดด้านล่างนี้ล้าสมัย แต่โชคดีที่เครื่องกำเนิดไฟฟ้ามาตรฐาน ES6 และyieldคีย์เวิร์ดและได้รับการสนับสนุนในทุกแพลตฟอร์ม ตัวอย่างของการขี้เกียจrange()ใช้yieldสามารถพบได้ที่นี่

นอกเหนือจากสิ่งที่กล่าวไปแล้ว Javascript 1.7+ ยังรองรับการทำซ้ำและเครื่องกำเนิดไฟฟ้าซึ่งสามารถใช้เพื่อสร้างrangesimlar เวอร์ชันที่เกียจคร้านและประหยัดหน่วยความจำxrangeใน Python2:

function range(low, high) {  
    return {
        __iterator__: function() {
            return {  
                next: function() {
                    if (low > high)
                        throw StopIteration;  
                    return low++;
                }
            }
        }
    }
}

for (var i in range(3, 5))  
  console.log(i); // 3,4,5

เมื่อรวมคำตอบทั้งสองจาก@Tadeckและ@georgเข้าด้วยกันฉันจึงได้สิ่งนี้:

function* range(start, stop, step = 1) {
    if (stop == null) {
        // one param defined
        stop = start;
        start = 0;
    }

    for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
        yield i;
    }
}

ในการใช้สำหรับลูปคุณต้องมี ES6 / JS1.7 for-of loop:

for (let i of range(5)) {
    console.log(i);
}
// Outputs => 0 1 2 3 4

for (let i of range(0, 10, 2)) {
    console.log(i);
}
// Outputs => 0 2 4 6 8

for (let i of range(10, 0, -2)) {
    console.log(i);
}
// Outputs => 10 8 6 4 2

พอร์ตของrangeฟังก์ชันจาก Python 2 มีให้โดยไลบรารียูทิลิตี้underscore.jsและlodash (พร้อมกับเครื่องมือที่มีประโยชน์อื่น ๆ อีกมากมาย) ตัวอย่างที่คัดลอกมาจากเอกสารขีดล่าง:

_.range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0);
=> []

สามารถทำได้โดยการติดเครื่องวนซ้ำเข้ากับเครื่องNumberต้นแบบ

  Number.prototype[Symbol.iterator] = function* () { 
     for (var i = 0; i <= this; i++) {
       yield i
     } 
  }

[...5] // will result in [0,1,2,3,4,5]

นำมาจากหลักสูตรของ Kyle Simpson Rethinking Asynchronous JavaScript

นี่คือส่วนขยายขนาดเล็กสำหรับหนึ่งในคำตอบในกรณีที่คุณต้องระบุทั้งตำแหน่งเริ่มต้นและตำแหน่งสิ้นสุดของช่วง:

let range = (start, end) => Array.from(Array(end + 1).keys()).slice(start);

จัดให้เลย

สิ่งนี้จะเขียน (หรือเขียนทับ) ค่าของแต่ละดัชนีด้วยหมายเลขดัชนี

Array.prototype.writeIndices = function( n ) {
    for( var i = 0; i < (n || this.length); ++i ) this[i] = i;
    return this;
};

หากคุณไม่ระบุตัวเลขจะใช้ความยาวปัจจุบันของอาร์เรย์

ใช้แบบนี้:

var array = [].writeIndices(10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

สำหรับการรับอาร์เรย์ขนาดxนี่คือซับเดียวโดยไม่ต้องใช้ไลบรารีใด ๆ

var range = n => Array(n + 1).join(1).split('').map((x, i) => i)

ทำงานเป็น

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

ต่อไปนี้เป็นการปรับฟังก์ชันrange ()ของ Python ให้เป็น JavaScript ตามธรรมชาติ:

// Generate range from start (inclusive) to stop (exclusive):
function* range(start, stop, step = 1) {
   if (stop === undefined) [start, stop] = [0, start];
   if (step > 0) while (start < stop) yield start, start += step;
   else if (step < 0) while (start > stop) yield start, start += step;
   else throw new RangeError('range() step argument invalid');
} 

// Examples:
console.log([...range(3)]);       // [0, 1, 2]
console.log([...range(0, 3)]);    // [0, 1, 2]
console.log([...range(0, 3, -1)]);// []
console.log([...range(0, 0)]);    // []
console.log([...range(-3)]);      // []
console.log([...range(-3, 0)]);   // [-3, -2, -1]

สนับสนุนอาร์กิวเมนต์ใด ๆ ที่สามารถเปรียบเทียบ0และstopและสามารถเพิ่มได้โดยstepและสามารถเพิ่มขึ้นโดยNumber.MAX_SAFE_INTEGERมันจะทำงานเหมือนกับรุ่นหลามเมื่อใช้กับจำนวนไม่เกิน

โปรดสังเกตกรณีมุมต่อไปนี้:

[...range(0, 0, 0)];        // RangeError: range() step argument invalid
[...range(Number.MAX_SAFE_INTEGER + 1, Number.MAX_SAFE_INTEGER + 2)];  // []
[...range(Number.MAX_SAFE_INTEGER + 2, Number.MAX_SAFE_INTEGER + 3)];  // Infinite loop
[...range(0.7, 0.8, 0.1)];  // [0.7, 0.7999999999999999]
[...range('1', '11')];      // ['1']
[...range('2', '22')];      // Infinite loop

ในทางตรงกันข้ามกับ@ Tadeck ของ , @ Volv ของและ@ janka102 ของคำตอบที่กลับมา[], undefinedหรือใส่ห่วงอนันต์เมื่อstepประเมิน0หรือNaNฟังก์ชั่นเครื่องกำเนิดไฟฟ้านี้พ่นยกเว้นคล้ายกับพฤติกรรมของงูใหญ่

ปรับปรุงเพิ่มเติมด้วยพารามิเตอร์เริ่มต้น ES6

let range = function*(start = 0, stop, step = 1) {
  let cur = (stop === undefined) ? 0 : start;
  let max = (stop === undefined) ? start : stop;
  for (let i = cur; step < 0 ? i > max : i < max; i += step)
    yield i
}

pythonicเลียนแบบrangeลักษณะการทำงานของPython ได้ดีที่สุดเท่าที่จะทำได้โดยใช้เครื่องกำเนิดไฟฟ้าของ JS ( yield) ซึ่งรองรับทั้งกรณีrange(stop)และrange(start, stop, step)กรณีการใช้งาน นอกจากนี้pythonic's rangeฟังก์ชั่นส่งกลับIteratorวัตถุคล้ายกับงูหลามที่สนับสนุนmapและfilterดังนั้นหนึ่งสามารถทำแฟนซีหนึ่งสมุทรที่ชอบ:

import {range} from 'pythonic';
// ...
const results = range(5).map(wouldBeInvokedFiveTimes);
// `results` is now an array containing elements from
// 5 calls to wouldBeInvokedFiveTimes

ติดตั้งโดยใช้npm:

npm install --save pythonic

การเปิดเผยข้อมูลฉันเป็นผู้เขียนและผู้ดูแล Pythonic

MDN แนะนำแนวทางนี้: ตัวสร้างลำดับ (ช่วง)

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

// Generate numbers range 0..4
console.log("range(0, 4, 1):", range(0, 4, 1));
// [0, 1, 2, 3, 4] 

// Generate numbers range 1..10 with step of 2 
console.log("\nrange(1, 10, 2):", range(1, 10, 2));
// [1, 3, 5, 7, 9]

// Generate the alphabet using Array.from making use of it being ordered as a sequence
console.log("\nrange('A'.charCodeAt(0), 'Z'.charCodeAt(0), 1).map(x => String.fromCharCode(x))", range('A'.charCodeAt(0), 'Z'.charCodeAt(0), 1).map(x => String.fromCharCode(x)));
// ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]

คุณสามารถใช้ไลบรารีขีดล่าง ประกอบด้วยฟังก์ชันที่มีประโยชน์มากมายสำหรับการทำงานกับอาร์เรย์และอื่น ๆ อีกมากมาย

มีฟังก์ชันใน JavaScript คล้ายกับ range () ของ Python หรือไม่

โซลูชันทั้งหมดที่นี่อ้างถึงช่วงของ Python 2 (อาจเป็นเพราะตัวอย่างโค้ดที่คุณให้) อย่างไรก็ตามใน Python 3 วิธี range () จะส่งคืนตัววนซ้ำ JavaScript ยังมีตัวทำซ้ำและมีพื้นที่ที่มีประสิทธิภาพมากกว่าการสร้างอาร์เรย์ทั้งหมดและจัดเก็บไว้ในหน่วยความจำ

ดังนั้นการแสดงrange(n)ฟังก์ชันของ Python 3 ที่แม่นยำยิ่งขึ้นก็คือArray(n).keys()ฟังก์ชั่น

ตัวอย่างเช่น:

for (let i of Array(n).keys()) {
  console.log(i) // 0, 1, 2, 3, ..., n
}

อีกหนึ่งตัวอย่าง (ซึ่งได้กล่าวถึงคำตอบอื่น ๆ แล้ว) การแปลงตัววนซ้ำเป็นอาร์เรย์ (ES6):

let ary = [...Array(n).keys()];
// ary = [0, 1, 2, 3, ..., n]

ยังไม่มีฟังก์ชันในตัวที่เทียบเท่าrange()กับรุ่นล่าสุด - ES2015 คุณสามารถสร้างการใช้งานของคุณเองได้ นี่เป็นรุ่นที่ จำกัด จำกัด เนื่องจากไม่คำนึงถึงพารามิเตอร์ขั้นตอน เพียงนาทีสูงสุด

const range = (min = null, max = null) =>
  Array.from({length:max ? max - min : min}, (v,k) => max ? k + min : k)

สิ่งนี้ทำได้โดยArray.fromวิธีการที่สามารถสร้างอาร์เรย์จากวัตถุใด ๆ ที่มีlengthคุณสมบัติ ดังนั้นการส่งผ่านวัตถุธรรมดาที่มีlengthคุณสมบัติเพียงอย่างเดียวจะสร้าง ArrayIterator ที่จะให้lengthจำนวนวัตถุ

นี่เป็นวิธีที่ฉันชอบ ช่วยให้คุณระบุหนึ่งหรือสองอินพุตเช่นใน Python

function range(start, end) {
  return Array.from(Array(end||start).keys()).slice(!!end*start)
}

นี่คือes6การใช้งานช่วงอื่น

// range :: (from, to, step?) -> [Number]
const range = (from, to, step = 1) => {
  //swap values if necesery
  [from, to] = from > to ? [to, from] : [from, to]
  //create range array
  return [...Array(Math.round((to - from) / step))]
    .map((_, index) => {
      const negative = from < 0 ? Math.abs(from) : 0
      return index < negative ? 
        from + index * step  :
        (index - negative + 1) * step
    })
}  

range(-20, 0, 5)
  .forEach(val => console.log(val))

for(const val of range(5, 1)){
   console.log(`value ${val}`)
}

ไม่ไม่มีเลย แต่คุณสามารถสร้างได้

ฉันเป็นส่วนหนึ่งของพฤติกรรม Python3 ของช่วง คุณจะพบด้านล่างของการใช้งาน JavaScript ของช่วง Python ():

function* range(start=0, end=undefined, step=1) {    
    if(arguments.length === 1) {end = start, start = 0}    
    
    [...arguments].forEach(arg => {    
        if( typeof arg !== 'number') {throw new TypeError("Invalid argument")}                               
    })    
    if(arguments.length === 0) {throw new TypeError("More arguments neede")}    
        
    if(start >= end) return                                                                                                                                     
    yield start    
    yield* range(start + step, end, step)    
}    
         
// Use Cases
console.log([...range(5)])

console.log([...range(2, 5)])

console.log([...range(2, 5, 2)])
console.log([...range(2,3)])
// You can, of course, iterate through the range instance.

สมมติว่าคุณต้องการช่วงง่ายๆด้วยขั้นตอนเดียว:

let range = (start, end)=> {
    if(start === end) return [start];
    return [start, ...range(start + 1, end)];
}

อื่น

let range = (start, end, step)=> {
    if(start === end) return [start];
    return [start, ...range(start + step, end)];
}

ดูข้อมูลเพิ่มเติมได้ที่นี่

มีฟังก์ชันใน JavaScript คล้ายกับ range () ของ Python หรือไม่

ในฐานะที่เป็นคำตอบก่อน: ไม่มีมีไม่ แต่คุณสามารถทำของคุณเอง ฉันเชื่อว่านี่เป็นแนวทางที่น่าสนใจสำหรับ ES6 มันทำงานคล้ายกับ Python 2.7 range()แต่มีไดนามิกมากกว่ามาก

function range(start, stop, step = 1) 
{
    // This will make the function behave as range(stop)
    if(arguments.length === 1)
    {
        return [...Array(arguments[0]).keys()]
    }

    // Adjusts step to go towards the stop value
    if((start > stop && !(step < 0)) ||
       (start < stop && !(step > 0)))
    {
        step *= -1
    }

    let returnArray = []
    // Checks if i is in the interval between start and stop no matter if stop
    // is lower than start or vice-versa
    for(let i = start; (i-start)*(i-stop) <= 0; i += step)
    {
        returnArray.push(i)
    }
    return returnArray
}

ฟังก์ชันนี้สามารถทำงานได้สามวิธี (เช่นเดียวกับช่วงของ Python ()):

1. range(stop)
2. range(start, stop)
3. range(start, stop, step)

ตัวอย่างเหล่านี้:

console.log(range(5))
console.log(range(-2, 2))
console.log(range(2, -2))
console.log(range(10, 20, 2))

จะให้ผลลัพธ์ดังต่อไปนี้:

[ 0, 1, 2, 3, 4 ]
[ -2, -1, 0, 1, 2 ]
[ 2, 1, 0, -1, -2 ]
[ 10, 12, 14, 16, 18, 20 ]

หมายเหตุว่าแทนที่จะทำซ้ำมากกว่าอาร์เรย์ที่มีinผู้ประกอบการ (เช่นงูหลาม) ofคุณต้องใช้ ดังนั้นiตัวแปรจะถือว่าค่าไม่ใช่ดัชนีขององค์ประกอบของอาร์เรย์

for(let i of range(5))
{
    // do something with i...
}

ตัวเลือกสำหรับ NodeJs คือการใช้ Buffer:

[...Buffer.alloc(5).keys()]
// [ 0, 1, 2, 3, 4 ]

สิ่งที่ดีคือคุณสามารถทำซ้ำได้โดยตรงบนบัฟเฟอร์:

Buffer.alloc(5).forEach((_, index) => console.log(index))
// 0
// 1
// 2
// 3
// 4

คุณไม่สามารถทำได้ด้วย Array ที่ไม่ได้เริ่มต้น:

Array(5).forEach((_, index) => console.log(index))
// undefined

แต่ใครในใจที่ถูกต้องใช้ Buffer เพื่อจุดประสงค์เช่นนี้;)

นี่คือวิธีที่ฉันทำ

let n = 5 
[...Array(n).keys()].map(x=>{console.log(x)})

เอาท์พุท

0
1
2
3
4