पायथन रेंज के समान जावास्क्रिप्ट फ़ंक्शन ()

Question 1

क्या पायथन के समान जावास्क्रिप्ट में एक फ़ंक्शन है range()?

मुझे लगता है कि हर बार निम्नलिखित पंक्तियों को लिखने से बेहतर तरीका होना चाहिए:

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

Question 2

नहीं , कोई नहीं है, लेकिन आप एक बना सकते हैं ।

पायथन के जावास्क्रिप्ट का कार्यान्वयन `range()`

पायथन में यह कैसे काम करता है , यह अनुकरण करने की कोशिश कर रहा हूं, मैं इसके समान कार्य करूंगा:

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()`जावास्क्रिप्ट और पायथन के बीच तुलना

यह निम्नलिखित तरीके से काम करता है:

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)रिटर्न [],

और इसका पायथन समकक्ष ठीक उसी तरह काम करता है (कम से कम उल्लेखित मामलों में):

>>> 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)
[]

तो अगर आपको पायथन के समान काम करने के लिए एक फ़ंक्शन की आवश्यकता है range(), तो आप उपर्युक्त समाधान का उपयोग कर सकते हैं।

Question 3

ES6 में एक बहुत ही सरल रेंज के लिए:

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

से bigOmega की टिप्पणी , इस का उपयोग कर छोटा किया जा सकता फैले वाक्य रचना :

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

Question 4

: नीचे दिया गया कोड अप्रचलित है, लेकिन सौभाग्य से ES6 मानकीकृत जनरेटर और yieldकीवर्ड है, और वे प्लेटफार्मों भर में सार्वभौमिक रूप से समर्थित हैं। यहाँrange() प्रयोग करके आलसी का एक उदाहरण yieldपाया जा सकता है ।

पहले से ही कहा गया है, इसके अलावा, जावास्क्रिप्ट 1.7+ पुनरावृत्तियों और जनरेटर के लिए समर्थन प्रदान करता है, जिसका उपयोग Python2 में एक आलसी, मेमोरी-कुशल संस्करण range, xrangeसिमलर बनाने के लिए किया जा सकता है :

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

Question 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 (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

Question 6

rangeपायथन 2 से फ़ंक्शन का एक पोर्ट अंडरस्कोर.ज और लॉश यूटिलिटी लाइब्रेरी (कई अन्य उपयोगी उपकरणों के साथ) द्वारा प्रदान किया जाता है । अंडरस्कोर डॉक्स से कॉपी किए गए उदाहरण:

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

Question 7

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]

काइल सिम्पसन के कोर्स रिथिंकिंग एसिंक्रोनस जावास्क्रिप्ट से लिया गया

Question 8

यहाँ एक उत्तर के लिए एक छोटा सा विस्तार है यदि आपको रेंज की शुरुआत और समाप्ति दोनों को निर्दिष्ट करने की आवश्यकता है:

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

Question 9

हेयर यू गो।

यह सूचकांक संख्या के साथ प्रत्येक सूचकांक के मूल्य को (या अधिलेखित) लिख देगा।

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]

Question 10

आकार की एक सरणी पाने के लिए x, यहां किसी भी पुस्तकालय का उपयोग किए बिना एक-लाइनर है

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

के रूप में काम करता है

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

Question 11

निम्नलिखित पायथन की रेंज का प्राकृतिक अनुकूलन है () जावास्क्रिप्ट के लिए कार्य:

// 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's , @ Volv's और @ janka102 के जवाब के विपरीत , जो लौटते हैं [], undefinedया stepमूल्यांकन करने पर एक अनंत लूप में प्रवेश करते हैं 0या NaN, यह जनरेटर फ़ंक्शन पायथन के व्यवहार के समान अपवाद फेंकता है।

Question 12

आगे 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
}

Question 13

pythonicपायथन के rangeव्यवहार की नकल करता है, यह जेएस के जनरेटर ( yield) का उपयोग कर सकता है , range(stop)और दोनों range(start, stop, step)मामलों का उपयोग कर सकता है। इसके अलावा, pythonicके 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 का अनुचर हूँ

Question 14

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

स्निपेट का विस्तार करें

Question 15

आप अंडरस्कोर लाइब्रेरी का उपयोग कर सकते हैं । इसमें सरणियों और कई और अधिक के साथ काम करने के लिए दर्जनों उपयोगी कार्य शामिल हैं।

Question 16

क्या जावास्क्रिप्ट में पायथन की रेंज () के समान एक फ़ंक्शन है?

यहां समाधान के सभी पायथन 2 की सीमा का उल्लेख कर रहे हैं (शायद कोड उदाहरण के कारण आपने दिया था)। हालांकि पायथन 3 में, रेंज () विधि एक पुनरावृत्ति देता है। जावास्क्रिप्ट में पुनरावृत्तियां भी हैं और वे पूरे सरणी को उत्पन्न करने और इसे मेमोरी में संग्रहीत करने की तुलना में अधिक स्थान कुशल हैं।

तो पायथन 3 के range(n)कार्य का अधिक सटीक प्रतिनिधित्व है 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]

Question 17

अभी भी कोई बिल्ट-इन फ़ंक्शन नहीं है, जो इसके बराबर है 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जो वस्तुओं की संख्या को उत्पन्न करेगा ।

Question 18

यह मेरा पसंदीदा तरीका है। यह आपको पायथन में एक या दो इनपुट निर्दिष्ट करने की अनुमति देता है।

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

Question 19

यहाँ 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}`)
}

स्निपेट का विस्तार करें

Question 20

नहीं, कोई नहीं है, लेकिन आप एक बना सकते हैं।

मैं रेंज के पायथन 3 व्यवहार का आंशिक हूँ। आप पायथन रेंज के जावास्क्रिप्ट के कार्यान्वयन के नीचे पाएंगे ():

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.

स्निपेट का विस्तार करें

Question 21

मान लें कि आपको एक एकल चरण के साथ एक सरल श्रेणी की आवश्यकता है:

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

अधिक के लिए यहां देखें ।

Question 22

क्या जावास्क्रिप्ट में पायथन की रेंज () के समान एक फ़ंक्शन है?

जैसा कि पहले उत्तर दिया गया: नहीं , वहाँ नहीं है। लेकिन आप अपना खुद का बना सकते हैं। मेरा मानना है कि यह ES6 के लिए एक दिलचस्प दृष्टिकोण है। यह पायथन 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
}

यह फ़ंक्शन तीन अलग-अलग तरीकों से व्यवहार कर सकता है (जैसे पायथन की रेंज ()):

range(stop)
range(start, stop)
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...
}

Question 23

NodeJs के लिए एक विकल्प बफर का उपयोग करना है:

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

क्या अच्छा है कि आप सीधे बफर पर पुनरावृति कर सकते हैं:

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

आप एक असिंचित एरे के साथ ऐसा नहीं कर सकते:

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

लेकिन, इस तरह से एक उद्देश्य के लिए कौन अपने सही दिमाग का उपयोग करता है;)

Question 24

यहाँ है कि मैं यह कैसे करते हैं

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

उत्पादन

पायथन रेंज के समान जावास्क्रिप्ट फ़ंक्शन ()

पायथन के जावास्क्रिप्ट का कार्यान्वयन range()

range()जावास्क्रिप्ट और पायथन के बीच तुलना

पायथन के जावास्क्रिप्ट का कार्यान्वयन `range()`

`range()`जावास्क्रिप्ट और पायथन के बीच तुलना