दिलचस्प पोस्ट
Django: लॉगिन के बाद पिछले पृष्ठ पर रीडायरेक्ट करें जावास्क्रिप्ट सरणी की घोषणा करते हुए "अर्रे ()" और "" के बीच अंतर क्या है? सी # में पॉप 3 का उपयोग कर ईमेल पढ़ना फॉर-लूप में सेट टाइमआउट सलग मानों को प्रिंट नहीं करता जावास्क्रिप्ट में% क्या होता है? व्यक्तिगत और निरंतर जेटेबल का सेल चयन उद्देश्य-सी में कस्टम प्रतिनिधि का उपयोग कैसे करें यूटीएफ 8 एन्कोडिंग के साथ सीएसवी के लिए एक्सेल मैं jQuery के साथ एक तत्व का चयन कैसे कर सकता हूं? जावास्क्रिप्ट या jQuery ब्राउज़र बैक बटन क्लिक डिटेक्टर सी # में एन्यूएम विशेषता का मतलब क्या है? LINQ का उपयोग करके सूची में डुप्लिकेट निकालें पृष्ठ या सामग्री के नीचे स्थित पाद लेख, जो भी कम हो रनटाइम पर निर्धारित किया गया upload_to के साथ Django FileField उत्सुकता से आवर्ती टेम्पलेट पैटर्न (सीआरटीपी) क्या है?

क्या जावास्क्रिप्ट में "सीमा ()" जैसी एक विधि है जो आपूर्ति की सीमा के आधार पर एक सरणी उत्पन्न करती है?

PHP में, आप कर सकते हैं …

range(1, 3); // Array(1, 2, 3) range("A", "C"); // Array("A", "B", "C") 

अर्थात्, एक ऐसा फ़ंक्शन होता है जिससे आपको ऊपरी और निचली सीमाओं को पार करके कई संख्याएं या वर्ण मिलते हैं।

क्या इस के लिए मूल रूप से जावास्क्रिप्ट में निर्मित कुछ है? यदि नहीं, तो मैं इसे कैसे लागू करूं?

वेब के समाधान से एकत्रित समाधान "क्या जावास्क्रिप्ट में "सीमा ()" जैसी एक विधि है जो आपूर्ति की सीमा के आधार पर एक सरणी उत्पन्न करती है?"

lodash.js _.range() फ़ंक्शन

 _.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] 

या बिना एक पुस्तकालय:

 Array.apply(null, Array(5)).map(function (_, i) {return i;}); => [0, 1, 2, 3, 4] 

ES6 संस्करण और चरित्र पुनरावर्तन

 [...Array(5).keys()]; => [0, 1, 2, 3, 4] String.fromCharCode(..._.range('A'.charCodeAt(0), 'D'.charCodeAt(0) + 1)); => "ABCD" 
 console.log([...Array(5).keys()]); 

संख्याओं के लिए आप ES6 Array.from() उपयोग कर सकते हैं, जो इन दिनों को छोड़कर इन सब चीज़ों में काम करता है :

 Array.from(new Array(20), (x,i) => i) 

जो 0 से 1 9 के बीच समावेशी एक सरणी बनाता है। इसे आगे इन रूपों में से एक को छोटा किया जा सकता है:

 Array.from(Array(20).keys()) // or [...Array(20).keys()] 

निम्न और ऊपरी सीमाओं को भी निर्दिष्ट किया जा सकता है, उदाहरण के लिए:

 Array.from(new Array(20), (x,i) => i + *lowerBound*) 

इस लेख का अधिक विवरण में वर्णन करते हैं: http://www.2ality.com/2014/05/es6-array-methods.html

यहां मेरा 2 सेंट है:

  function range(start, count) { return Array.apply(0, Array(count)) .map(function (element, index) { return index + start; }); } 

यह वर्ण और संख्याओं के लिए काम करता है, वैकल्पिक चरण के साथ आगे या पीछे की ओर जा रहा है

 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" && (step = 1); if (end < start) { step = -step; } if (typeofStart == "number") { while (step > 0 ? end >= start : end <= 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 > 0 ? end >= start : end <= start) { range.push(String.fromCharCode(start)); start += step; } } else { throw TypeError("Only string and number types are supported"); } return range; } 

जेएसफ़ैल्ड

यदि देशी प्रकारों को बढ़ाने से आपकी बात है, तो उसे Array.range निर्दिष्ट करें।

 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" && (step = 1); if (end < start) { step = -step; } if (typeofStart == "number") { while (step > 0 ? end >= start : end <= 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 > 0 ? end >= start : end <= 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)); 
 Array.range= function(a, b, step){ var A= []; if(typeof a== 'number'){ A[0]= a; step= step || 1; while(a+step<= 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'] 

साधारण रेंज फ़ंक्शन:

 function range(start, stop, step){ var a=[start], b=start; while(b<stop){b+=step;a.push(b)} return a; }; 
 var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l); 

चाल करने के लिए आसान फ़ंक्शन, नीचे कोड स्निपेट चलाएं

 function range(start, end, step, offset) { var len = (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1; var direction = start < end ? 1 : -1; var startingPoint = start - (direction * (offset || 0)); var stepSize = direction * (step || 1); return Array(len).fill(0).map(function(_, index) { return startingPoint + (stepSize * index); }); } console.log('range(1, 5)=> ' + range(1, 5)); console.log('range(5, 1)=> ' + range(5, 1)); console.log('range(5, 5)=> ' + range(5, 5)); console.log('range(-5, 5)=> ' + range(-5, 5)); console.log('range(-10, 5, 5)=> ' + range(-10, 5, 5)); console.log('range(1, 5, 1, 2)=> ' + range(1, 5, 1, 2)); 

पर्वतमाला उत्पन्न करने के लिए मानक जावास्क्रिप्ट में एक अंतर्निहित कार्य नहीं है कई जावास्क्रिप्ट फ़्रेमवर्क इस तरह की सुविधाओं के लिए समर्थन जोड़ते हैं, जिसमें प्रोटोटाइप.जेएस शामिल हैं ।

यदि आप दोबारा जांच करना चाहते हैं, तो निश्चित संसाधन ECMA-262 मानक है ।

मेरा नया पसंदीदा प्रपत्र ( ES2015 )

 Array(10).fill(1).map((x, y) => x + y) 

ठीक है, जावास्क्रिप्ट में हमारे पास पीएचपी जैसी कोई range() फ़ंक्शन नहीं है, इसलिए हमें उस फ़ंक्शन को बनाने की जरूरत है जो काफी आसान है, मैं आपके लिए एक-लाइनर फ़ंक्शन के कुछ लिखता हूं और उन्हें नंबर और अक्षर के लिए अलग करता हूं:

नंबर के लिए :

 function numberRange (start, end) { return new Array(end - start).fill().map((d, i) => i + start); } 

और इसे इस तरह कॉल करें:

 numberRange(5, 10); //[5, 6, 7, 8, 9] 

अक्षर के लिए :

 function alphabetRange (start, end) { return new Array(end.charCodeAt(0) - start.charCodeAt(0)).fill().map((d, i) => String.fromCharCode(i + start.charCodeAt(0))); } 

और इसे इस तरह कॉल करें:

 alphabetRange('c', 'h'); //["c", "d", "e", "f", "g"] 

सद्भाव फैल ऑपरेटर और तीर कार्यों का उपयोग करना:

 var range = (start, end) => [...Array(end - start + 1)].map((_, i) => start + i); 

उदाहरण:

 range(10, 15); [ 10, 11, 12, 13, 14, 15 ] 

कुछ रेंज फ़ंक्शंस पर कुछ शोध किया था। इन फ़ंक्शन को करने के विभिन्न तरीकों की तुलना में jsperf की तुलना करें । निश्चित रूप से एक परिपूर्ण या संपूर्ण सूची नहीं है, लेकिन मदद करनी चाहिए 🙂

विजेता हैं…

 function range(lowEnd,highEnd){ var arr = [], c = highEnd - lowEnd + 1; while ( c-- ) { arr[c] = highEnd-- } return arr; } range(0,31); 

फ़ायरफ़ॉक्स पर तकनीकी रूप से यह सबसे तेज नहीं है, लेकिन क्रोम पर पागल गति अंतर (आईमो) इसके लिए तैयार है।

इसके अलावा दिलचस्प अवलोकन है कि फ़ायरफ़ॉक्स की तुलना में इन सरणी कार्यों के साथ क्रोम कितना तेज है क्रोम कम से कम 4 या 5 गुना तेज है

एक दिलचस्प चुनौती यह करने के लिए सबसे कम कार्य लिखने के लिए होगी। बचाव के लिए पुनरावर्ती!

 function r(a,b){return a>b?[]:[a].concat(r(++a,b))} 

बड़ी रेंज पर धीमा होना चाहिए, लेकिन सौभाग्य से क्वांटम कंप्यूटर कोने के आसपास हैं

एक अतिरिक्त बोनस यह है कि यह अस्पष्ट है क्योंकि हम सभी जानते हैं कि हमारे कोड को छिपी हुई आँखों से छिपाना कितना ज़रूरी है

फ़ंक्शन को वाकई और पूरी तरह से अस्पष्ट करने के लिए, ऐसा करें:

 function r(a,b){return (a<b?[a,b].concat(r(++a,--b)):a>b?[]:[a]).sort(function(a,b){return ab})} 

मैं इस तरह से कुछ कोड होगा:

 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] 

यह पायथन रेंज के समान व्यवहार करता है:

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

एक बहुत ही कम Array.from() जिसे Array.from() को भारी रूप से प्रयोग किया जा सकता है, निम्न प्रकार से बनाया जा सकता है: Array.from() स्थैतिक विधि पर विशेष ध्यान देना:

 const getRange = (start, stop) => Array.from( new Array((stop - start) + 1), (_, i) => i + start ); 

यद्यपि यह PHP से नहीं है, लेकिन पायथन से range का एक अनुकरण है।

 function range(start, end) { var total = []; if (!end) { end = start; start = 0; } for (var i = start; i < end; i += 1) { total.push(i); } return total; } console.log(range(10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] console.log(range(0, 10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] console.log(range(5, 10)); // [5, 6, 7, 8, 9] 

आप रद्दी या अंडेस्कोर। जेएस range उपयोग कर सकते हैं:

 var range = require('lodash/range') range(10) // -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] 

वैकल्पिक रूप से, यदि आपको केवल एक पूर्णांक संख्या की आवश्यकता होती है तो आप ऐसा कुछ कर सकते हैं:

 Array.apply(undefined, { length: 10 }).map(Number.call, Number) // -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] 

ES6 range जनरेटर के साथ कार्यान्वित किया जा सकता है:

 function* range(start=0, end=null, step=1) { if (end == null) { end = start; start = 0; } for (let i=start; i < end; i+=step) { yield i; } } 

यह क्रियान्वयन बड़े अनुक्रमों को दोबारा करते समय स्मृति को सहेजता है, क्योंकि किसी सरणी में सभी मानों को अमल करने की आवश्यकता नहीं है:

 for (let i of range(1, oneZillion)) { console.log(i); } 

ईएस 6 जेनरेटर का उपयोग करते हुए एक अन्य संस्करण ( ES6 जनरेटर के साथ महान पाओलो मोरेटी का जवाब देखें):

 const RANGE = (a,b) => Array.from((function*(x,y){ while (x <= y) yield x++; })(a,b)); console.log(RANGE(3,7)); // [ 3, 4, 5, 6, 7 ] 

या, अगर हमें केवल आवश्यनीय की आवश्यकता होती है, तो:

 const RANGE_ITER = (a,b) => (function*(x,y){ while (x++< y) yield x; })(a,b); for (let n of RANGE_ITER(3,7)){ console.log(n); } 

समानता जेनरेटर का उपयोग करना, IE11 को छोड़कर सभी ब्राउज़रों द्वारा समर्थित :

 var take = function (amount, generator) { var a = []; try { while (amount) { a.push(generator.next()); amount -= 1; } } catch (e) {} return a; }; var takeAll = function (gen) { var a = [], x; try { do { x = a.push(gen.next()); } while (x); } catch (e) {} return a; }; var range = (function (d) { var unlimited = (typeof d.to === "undefined"); if (typeof d.from === "undefined") { d.from = 0; } if (typeof d.step === "undefined") { if (unlimited) { d.step = 1; } } else { if (typeof d.from !== "string") { if (d.from < d.to) { d.step = 1; } else { d.step = -1; } } else { if (d.from.charCodeAt(0) < d.to.charCodeAt(0)) { d.step = 1; } else { d.step = -1; } } } if (typeof d.from === "string") { for (let i = d.from.charCodeAt(0); (d.step > 0) ? (unlimited ? true : i <= d.to.charCodeAt(0)) : (i >= d.to.charCodeAt(0)); i += d.step) { yield String.fromCharCode(i); } } else { for (let i = d.from; (d.step > 0) ? (unlimited ? true : i <= d.to) : (i >= d.to); i += d.step) { yield i; } } }); 

उदाहरण

लेना

उदाहरण 1।

take जितना जितना हो सके उतना ही लेता है

take(10, range( {from: 100, step: 5, to: 120} ) )

रिटर्न

[100, 105, 110, 115, 120]

उदाहरण 2

निक्सीरी के to नहीं

take(10, range( {from: 100, step: 5} ) )

रिटर्न

[100, 105, 110, 115, 120, 125, 130, 135, 140, 145]

सभी को ले

उदाहरण 3

निक्सीरी from नहीं

takeAll( range( {to: 5} ) )

रिटर्न

[0, 1, 2, 3, 4, 5]

उदाहरण 4

takeAll( range( {to: 500, step: 100} ) )

रिटर्न

[0, 100, 200, 300, 400, 500]

उदाहरण 5

takeAll( range( {from: 'z', to: 'a'} ) )

रिटर्न

["z", "y", "x", "w", "v", "u", "t", "s", "r", "q", "p", "o", "n", "m", "l", "k", "j", "i", "h", "g", "f", "e", "d", "c", "b", "a"]

आप lodash फ़ंक्शन _.range(10) https://lodash.com/docs#range का उपयोग कर सकते हैं

जहाँ तक किसी दिए गए श्रेणी के लिए एक संख्यात्मक सरणी पैदा करना है, मैं इसका उपयोग करता हूं:

 function range(start, stop) { var array = []; var length = stop - start; for (var i = 0; i <= 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] 

जाहिर है, यह वर्णमाला सरणियों के लिए काम नहीं करेगा।

डी 3 में भी एक अंतर्निहित रेंज फ़ंक्शन है। https://github.com/mbostock/d3/wiki/Arrays#d3_range देखें:

d3.range ([शुरू,] रोक [, कदम])

एक अरैमेटिक प्रगति युक्त एक सरणी उत्पन्न करता है, पायथन के अंतर्निर्मित रेंज के समान। इस पद्धति का उपयोग अक्सर संख्यात्मक या पूर्णांक मानों के क्रम पर पुनरावृत्त करने के लिए किया जाता है, जैसे कि सरणी में अनुक्रमणिका। पायथन संस्करण के विपरीत, तर्कों को पूर्णांक होने की आवश्यकता नहीं है, हालांकि परिणाम अधिक अनुमान लगाते हैं यदि वे फ़्लोटिंग बिंदु सटीक होने के कारण होते हैं यदि कदम छोड़ा गया है, तो इसका डिफ़ॉल्ट 1

उदाहरण:

 d3.range(10) // returns [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

मुझे इस धागे में आने के लिए हैरान हुआ और मेरे समाधान की तरह कुछ भी नहीं देख पा रहा था (शायद मुझे एक जवाब नहीं मिला), तो यहां यह है। मैं ES6 सिंटैक्स में एक साधारण श्रेणी फ़ंक्शन का उपयोग करता हूं:

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

लेकिन यह केवल तब काम करता है जब आगे की गिनती (यानी शुरू <अंत), इसलिए हम इसे थोड़ी देर में संशोधित कर सकते हैं जैसे:

 const range = (b, e) => Array.apply(null, Array(Math.abs(e - b))).map((_, i) => {return b < e ? i+b : bi;}); 

यह ईएस 6 में केवल संख्याओं के साथ ऐसा करने का एक अच्छा छोटा रास्ता है (इसकी गति की तुलना नहीं पता):

 Array.prototype.map.call(' '.repeat(1 + upper - lower), (v, i) => i + lower) 

एकल वर्णों की श्रेणी के लिए, आप इसे थोड़ा संशोधित कर सकते हैं:

 Array.prototype.map.call(' '.repeat(1 + upper.codePointAt() - lower.codePointAt()), (v, i) => String.fromCodePoint(i + lower.codePointAt())); 

रेंज का उपयोग करके पूरा ES6 कार्यान्वयन ([प्रारंभ,] [[कदम]] रोकें हस्ताक्षर:

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

यदि आप स्वचालित नकारात्मक कदम चाहते हैं, तो जोड़ें

 if(stop<start)step=-Math.abs(step) 

या अधिक न्यूनतर:

 range=(b, e, step=1)=>{ if(!e){e=b;b=0} return Array.from(new Array(int((eb)/step)), (_,i) => b<e? b+i*step : bi*step) } 

अगर आपके पास विशाल रेंज पाओलो मोरेटी के जनरेटर दृष्टिकोण को देखते हैं

मुझे पीएसए में एक के बराबर जेएस रेंज फ़ंक्शन मिल गया है, और यहां आश्चर्यजनक रूप से काम करता है । आगे और पिछड़े कार्य करता है, और पूर्णांक, फ़्लोट्स और वर्णों के साथ काम करता है!

 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) && !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 += walker; } } else { while (inival >= endval) { matrix.push(((chars) ? String.fromCharCode(inival) : inival)); inival -= walker; } } return matrix; } 

और यहाँ minified संस्करण है:

 function range(h,c,b){var i=[];var d,f,e;var a=b||1;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+=a}}else{while(d>=f){i.push(((g)?String.fromCharCode(d):d));d-=a}}return i}; 

अच्छा पिछड़े संगतता के साथ एक अधिक रूबी की तरह दृष्टिकोण के लिए:

range([begin], end = 0) जहां begin और end संख्या हैं

 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++ ) { result.push(begin + i * modifier); } return result; } 

उदाहरण:

 range(3); //=> [0, 1, 2, 3] range(-2); //=> [0, -1, -2] range(1, 2) //=> [1, 2] range(1, -2); //=> [1, 0, -1, -2] 

यहाँ मेरा समाधान है जो पायथन की नकल करता है निचले भाग में आप इसका उपयोग करने के कुछ उदाहरण पा सकते हैं। यह संख्याओं के साथ काम करता है, जैसे पायथन की range :

 var assert = require('assert'); // if you use Node, otherwise remove the asserts var L = {}; // L, ie '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 += step) { li.push(i); } } else { for (i = start; i > end; i += step) { li.push(i); } } return li; } 

उदाहरण:

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

2010 के चश्मे (यानी, यह 2016 ईएस 6 जनरेटर के साथ) को कोडित है पायथन की range() फ़ंक्शन का अनुकरण करने के विकल्प के साथ, यहां मेरा ले लिया गया है।

 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 < start ? -1 : 1; } var length = Math.max(Math.ceil((end - start) / step), 0); var out = Array(length); for (var idx = 0; idx < 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: '&' 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) || (typeof step != 'number')) { step = last < first ? -1 : 1; } if ((first == -1) || (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++, 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; } 

उदाहरण:

 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]