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

Question

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

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

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

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

Comments

प्रोटोटाइप .js का $Rकार्य है, लेकिन इसके अलावा मैं वास्तव में ऐसा नहीं सोचता।

— यी जियांग

इस (संबंधित) प्रश्न के कुछ उत्कृष्ट उत्तर हैं: stackoverflow.com/questions/6299500/…

— btk

Array.from("ABC") //['A', 'B', 'C']यह सबसे निकटतम चीज है जिसे मैं प्रश्न के दूसरे भाग के लिए पा सकता हूं।

— एंड्रयू_ १५१०

@ एंड्रयू_1510 आप split("")वहां भी इस्तेमाल कर सकते हैं

— एलेक्स

जब प्रेमी बंधु शून्य होता है तो यह ऑनलाइनर:Array.apply(null, { length: 10 }).map(eval.call, Number)

— csharpfolk

Answer 1

नंबर

[...Array(5).keys()];
 => [0, 1, 2, 3, 4]

चरित्र पुनरावृत्ति

String.fromCharCode(...[...Array('D'.charCodeAt(0) - 'A'.charCodeAt(0) + 1).keys()].map(i => i + 'A'.charCodeAt(0)));
 => "ABCD"

यात्रा

for (const x of Array(5).keys()) {
  console.log(x, String.fromCharCode('A'.charCodeAt(0) + x));
}
 => 0,"A" 1,"B" 2,"C" 3,"D" 4,"E"

कार्यों के रूप में

function range(size, startAt = 0) {
    return [...Array(size).keys()].map(i => i + startAt);
}

function characterRange(startChar, endChar) {
    return String.fromCharCode(...range(endChar.charCodeAt(0) -
            startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

टाइप किए गए कार्यों के रूप में

function range(size:number, startAt:number = 0):ReadonlyArray<number> {
    return [...Array(size).keys()].map(i => i + startAt);
}

function characterRange(startChar:string, endChar:string):ReadonlyArray<string> {
    return String.fromCharCode(...range(endChar.charCodeAt(0) -
            startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

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]
String.fromCharCode(..._.range('A'.charCodeAt(0), 'D'.charCodeAt(0) + 1));
 => "ABCD"

एक पुस्तकालय के बिना पुराने गैर es6 ब्राउज़र:

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

console.log([...Array(5).keys()]);

(ईएस 6 क्रेडिट पीटरसन और अन्य टिप्पणीकारों के लिए)

Comments

क्योंकि अगर यह कहीं भी उपयोगी है तो शायद यह JS में उपयोगी है। (जे एस कार्यात्मक प्रोग्रामिंग प्रकार सामान है, जो एक सीमा से फायदा हो सकता (0 बयान कर सकते हैं कि और एक हजार अन्य कारणों से यह कुछ semirare मामले में उपयोगी हो सकता है)।

— Lodewijk

किसी भी विचार क्यों बस (new Array(5)).map(function (value, index) { return index; })काम नहीं करेगा? यह [undefined × 5]मेरे लिए Chrome DevTools में लौटता है ।

— लुईस

@Lewis क्योंकि इसके साथ परिभाषित एक सरणी में खाली स्लॉट होते हैं जो इसके साथ map()या उसके किसी दोस्त के साथ iterated नहीं होंगे ।

— एलेक्स

Array.from (Array (5) .keys ())

— nils petersohn

Array(5).fill()भी mappable है

— nils petersohn

Answer 2

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

छोटा संस्करण:

Array.from({length: 20}, (x,i) => i);

लंबा संस्करण:

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

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

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

Comments

पहला उदाहरण भी सरल किया जा सकता है [... ऐरे (20) .keys ()]

— डेल्पाउइट

Array.from()विधि की तुलना में थोड़ा अधिक रसीला , और दोनों की तुलना में तेज़:Array(20).fill().map((_, i) => i)

— स्टु कॉक्स

@ डेलपॉइट भयानक! आपको इसे एक अलग उत्तर देना चाहिए, और मैं इसके लिए वोट करूँगा! यह इस डुप्लिकेट का भी सही जवाब है ।

— जिब

@ डेलपौइट @ जीब और यह भी:Array.from({length: end - start}, (v, k) => k + start)

— आदित्य सिंह

@ icc97 हां, लिंटर शिकायत कर सकते हैं, हालांकि जावास्क्रिप्ट में एक फ़ंक्शन तर्क को छोड़ दिया गया है जो पास होने के समान है undefined, इसलिए fill()(बिना किसी तर्क के) गलत नहीं है । भरण मूल्य का उस समाधान में उपयोग नहीं किया जाता है, इसलिए यदि आप चाहें तो fill(0)कुछ पात्रों को बचाने के लिए उपयोग कर सकते हैं ।

— स्टु कॉक्स

Answer 3

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

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

और अगर आपको एक stepपरम के साथ एक समारोह की आवश्यकता है :

const range = (start, stop, step = 1) =>
  Array(Math.ceil((stop - start) / step)).fill(start).map((x, y) => x + y * step)

Comments

सीमा = (प्रारंभ, रोक, चरण = 1) => सरणी (रोक - प्रारंभ) .fill (प्रारंभ) .map ((x, y) => x + y * चरण)

— rodfersou

@rodfersou FYI करें: आपका उदाहरण गलत है। stopवास्तव में स्टॉप / एंड पोजीशन नहीं है लेकिन गिनती / दूरी है। (कोई अपराध नहीं, बस लोगों को टाइपो के बारे में जागरूक करने के लिए)

— F Lekschas

भ्रमित करने के लिए - एफ लेक्सचा की टिप्पणी के बाद rodfersou के संपादन के कारण, उसका कोड अब सही है।

— eedrah

आप जिस तर्क से गुजरते Array(Math.ceil((stop - start) / step) + 1)हैं +1, उसे वास्तव में php के "समावेशी" व्यवहार की नकल करने की आवश्यकता है।

— जोहान डेटमर

यह शीर्ष उत्तर है जो वास्तव में एक जावास्क्रिप्ट फ़ंक्शन के पूर्ण प्रश्न का उत्तर देता है जो पूरी तरह से एक rangeविधि को लागू करता है। वर्तमान में इसके अतिरिक्त सभी लोग (लॉश के अलावा _.range) स्टार्ट, स्टॉप और स्टेप के साथ एक वास्तविक रेंज फ़ंक्शन के बजाय बुनियादी पुनरावृत्तियों को लागू करते हैं

— icc97

Answer 4

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

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

Comments

उच्च क्रम के कार्यों का उत्कृष्ट उपयोग।

— फ़रज़ाद YZ

यह वास्तव में गलत है क्योंकि सवाल शुरू और अंत मूल्यों के लिए पूछ रहा है। प्रारंभ और गिनती / दूरी नहीं।

— जेम्स रॉबी

Answer 5

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

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;

}

jsFiddle ।

यदि देशी प्रकार बढ़ाना आपकी बात है, तो इसे असाइन करें 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));

Answer 6

सरल रेंज समारोह:

function range(start, stop, step) {
    var a = [start], b = start;
    while (b < stop) {
        a.push(b += step || 1);
    }
    return a;
}

---

BitInt डेटा प्रकार को शामिल करने के लिए कुछ चेक शामिल किए जा सकते हैं, यह सुनिश्चित करते हुए कि सभी चर समान हैं typeof start:

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 < stop) {
        a.push(b += step);
    }
    return a;
}

---

stopउदाहरण के लिए परिभाषित मूल्यों से अधिक को हटाने के लिए range(0,5,2)शामिल होगा 6, जो नहीं होना चाहिए।

function range(start, stop, step) {
    var a = [start], b = start;
    while (b < stop) {
        a.push(b += step || 1);
    }
    return (b > stop) ? a.slice(0,-1) : a;
}

Comments

प्रयोग करने योग्य और पठनीय के लिए PLUS संयुक्त राष्ट्र संघ। बेस्ट कोड स्निपेट मैंने लंबे समय में देखा है।

— मन्स्तो mon

यह तब काम नहीं करता है step != 1, जब whileहालत को ध्यान stepमें रखना चाहिए। डिफ़ॉल्ट stepमान के साथ मेरा अद्यतन किया गया संस्करण : फ़ंक्शन रेंज (प्रारंभ, रोक, चरण) {चरण = चरण || 1 var a = [start], b = start; जबकि ((बी + स्टेप) <स्टॉप) {कंसोल.लॉग ("बी:" + बी + "।: ए:" ए + ए "।)); बी + = कदम; a.push (ख); } वापसी a; }

— डेवहरिस

@daveharris मैं, ऊपर एक डिफ़ॉल्ट कदम जोड़ा (step || 1)।

— श्री पॉलीविरल

Answer 7

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

Comments

आपको वास्तव में Arrayप्रोटोटाइप पर जेरी-रिग तरीके नहीं चाहिए ।

— संयोजक अष्टकोणीय

यह विधि केवल पूर्णांकों और वर्णों के साथ काम करती है। यदि पैरामीटर अशक्त, अपरिभाषित, NaN, बूलियन, सरणी, ऑब्जेक्ट, आदि हैं, तो यह विधि निम्न त्रुटि देता है undefined method toUpperCase to etc:!

— विक्टर

`` `यदि (टाइप करें तो! == 'नंबर' से & टाइप करें! == 'स्ट्रिंग') {नया टाइप लिखें ('पहला पैरामीटर एक नंबर या एक वर्ण होना चाहिए')} अगर (टाइपो टू! =) नंबर '&& टाइपऑफ़ से! ==' स्ट्रिंग ') {थ्रो न्यू टाइपइर्रर (' पहला पैरामीटर एक नंबर या एक वर्ण होना चाहिए ')} `` `

— विक्टर

Answer 8

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

के लिए नंबर :

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

Comments

मुझे लगता है कि इन कार्यों में ऑफ-बाय-वन त्रुटियां हैं। होना चाहिए Array(end - start + 1), और Array(end.charCodeAt(0) - start.charCodeAt(0) + 1)।

— इयरकानल

Answer 9

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

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

यहाँ इसका उपयोग कैसे करना है

रेंज (प्रारंभ, अंत, चरण = 1, ऑफसेट = 0);

• समावेशी - आगे range(5,10) // [5, 6, 7, 8, 9, 10]
• समावेशी - पिछड़ा range(10,5) // [10, 9, 8, 7, 6, 5]
• पीछे जाओ range(10,2,2) // [10, 8, 6, 4, 2]
• अनन्य - आगे range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• ऑफसेट - विस्तार range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• ऑफसेट - हटना range(5,10,0,-2) // [7, 8]
• चरण - विस्तार range(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]

उम्मीद है यह आपको उपयोगी होगा।

---

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

मूल रूप से मैं पहले परिणामी सरणी की लंबाई की गणना कर रहा हूं और उस लंबाई के लिए एक शून्य भरा सरणी बनाता हूं, फिर इसे आवश्यक मानों के साथ भरें

• (step || 1)=> और इस तरह के अन्य लोगों के मूल्य का उपयोग करें stepऔर अगर इसके 1बजाय उपयोग प्रदान नहीं किया गया था
• हम परिणाम सरणी की लंबाई की गणना करके (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1)इसे सरल बनाने के लिए उपयोग करते हैं (अंतर दोनों दिशाओं / चरणों में ऑफसेट)
• लंबाई प्राप्त करने के बाद, फिर हम यहां चेक का उपयोग करके प्रारंभिक मानों के साथ एक खाली सरणी बनाते new Array(length).fill(0); हैं
• अब हमारे पास [0,0,0,..]लंबाई के लिए एक सरणी है। हम इस पर मैप करते हैं और उन मानों के साथ एक नया एरे लौटाते हैं जिन्हें हमें उपयोग करके आवश्यक हैArray.map(function() {})
• var direction = start < end ? 1 : 0;जाहिर है कि अगर हम पिछड़े होने की जरूरत startसे छोटे नहीं endहैं। मेरा मतलब है 0 से 5 या इसके विपरीत जा रहा है
• हर यात्रा पर, startingPoint+ stepSize* indexइच्छा हमें मूल्य हम जरूरत देता है

Comments

हांडी, सबसे निश्चित रूप से। सरल? क्षमा करें मैं असहमत हूं; इसके बावजूद कि आप इसे एक लाइनर बनाते हैं। पाइथन के आने से यह झटका है।

— पास्कलवूटेन

@PascalvKooten, हाँ, यह बहुत अच्छा होता अगर वहाँ उस पद्धति का निर्माण किया जाता जैसे कि मुझे लगता है कि अजगर है, लेकिन यह सबसे सरल था जिसे मैं करके आ सकता था। और यह मेरी परियोजनाओं में काम आने वाला साबित हुआ है।

— अजराफती

एक दर्दनाक जटिल कोड स्निपेट को पोस्ट करना, विशेष रूप से एक-लाइनर के रूप में और यह कैसे काम करता है इसका कोई स्पष्टीकरण नहीं है? एक अच्छा एसओ उत्तर का खराब उदाहरण , भले ही "काम" हो या न हो।

— मदरब्रेक्स

@Madbreaks, हाँ तुम सही हो। मैं इसे एक लाइनर बनाने के लिए अनुभवहीन हूं। बस सभी को एक त्वरित और आसान समाधान देना चाहता था

— azerafati

Answer 10

var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);

Comments

@ मिल्कवॉन्ग, _मैपिंग कॉलबैक में तर्क का एक नाम है। आप जानते हैं, कुछ भाषाओं में आप _एक नाम के रूप में इंगित करते हैं कि चर का उपयोग नहीं किया जाता है।

— क्लेसुन

हालांकि, _इस तर्क के माध्यम से पारित नहीं किया गया है range। क्यों नहीं?

— निकक वोंग

बहुत साफ़! हालाँकि, यह ध्यान रखना महत्वपूर्ण है कि यह किसी IE या ओपेरा पर काम नहीं करता है।

— राफेल जेवियर

इस उत्तर को स्पष्टीकरण की आवश्यकता है, क्योंकि यह एसओ के लिए एक खराब फिट खड़ा है।

— मैडब्रेक्स

@ RafaelXavier IE पर Array.fill () पॉलीफ़िल के

— mwag

Answer 11

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

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

उदाहरण:

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

Comments

यह सबसे अच्छा जवाब है!

— हेनरी एच।

हालांकि सबसे तेज नहीं है।

— mjwrazor

इस मामले में '_' प्रतीक क्या दर्शाता है?

— ओलेह बेरेहोव्स्काई

@OlehBerehovskyi इसका मतलब एक लंबो फंक्शन पैरामीटर है जिसका आपके पास वास्तव में उपयोग करने का कोई इरादा नहीं है। एक लिंटर जो अप्रयुक्त चर के बारे में चेतावनी देता है, उसे अनदेखा करना चाहिए।

— मीका ज़ोल्टू

Answer 12

--- अद्यतन (सरलीकरण के लिए @lokhmakov के लिए धन्यवाद) ---

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

const RANGE = (x,y) => Array.from((function*(){
  while (x <= y) yield x++;
})());

console.log(RANGE(3,7));  // [ 3, 4, 5, 6, 7 ]

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

const RANGE_ITER = (x,y) => (function*(){
  while (x <= y) yield x++;
})();

for (let n of RANGE_ITER(3,7)){
  console.log(n);
}

// 3
// 4
// 5
// 6
// 7

--- सामान्य कोड था: ---

const RANGE = (a,b) => Array.from((function*(x,y){
  while (x <= y) yield x++;
})(a,b));

तथा

const RANGE_ITER = (a,b) => (function*(x,y){
  while (x <= y) yield x++;
})(a,b);

Comments

बस const range = (x, y) => Array.from(function* () { while (x <= y) yield x++; }())

— लखमाकोव

@lokhmakov हाँ, आप सही हैं। धन्यवाद! बस मेरे जवाब में अपना कोड लागू किया।

— हीरो क्व

Answer 13

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

विजेता हैं...

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

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

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

Comments

ध्यान दें कि इसकी तुलना रेंज फ़ंक्शंस के खिलाफ की गई थी जिसमें एक स्टेप साइज़ पैरामीटर शामिल था

— बाइनरीफंट

Answer 14

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

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

Comments

हालांकि मुझे यकीन है कि 2010 में एक अच्छा जवाब है, इसे अब सबसे अच्छा तरीका नहीं माना जाना चाहिए। आपको निर्मित प्रकारों में विस्तार नहीं करना चाहिए, जैसे कि प्रोटोटाइप.js को करने के लिए ana

— दाना वुडमैन

@DanaWoodman इसे लाने के लिए धन्यवाद - मैंने उत्तर को प्रोटोटाइप के संदर्भ में बाहर निकालने के लिए अपडेट किया है। क्योंकि यह 2018 में वास्तव में बहुत अप्रचलित है

— माइक दिनेस्कु

खैर यह सब मदद नहीं की।

— पिथिकोस

@Pithikos मुझे लगता है कि यह सवाल तब से संपादित किया गया है क्योंकि यह मूल रूप से पूछा गया था और ओपी यह जानना चाहता था कि क्या जेएस में कोई देशी रेंज फ़ंक्शन है।

— माइक दिनेस्कु

Answer 15

आप लॉश या Undescore.js का उपयोग कर सकते हैं 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);
}

Comments

ES6 भाग अब इस प्रश्न का सही उत्तर है। मैं अन्य हिस्सों को हटाने की सिफारिश करूंगा, जो अन्य उत्तरों से ढंके हुए हैं।

— जून तक

जनरेटर कुछ अजीब हैं अगर एक लूप के बाहर उपयोग किया जाता है: x = रेंज (1, 10); // {} x; // {} // एक खाली मानचित्र डब्ल्यूटीएफ जैसा दिखता है !? x.next ()। मान; // ठीक 1; x [3] // अपरिभाषित, केवल वास्तविक सरणी के साथ

— Anona112

@ Anona112 आप Array.fromजनरेटर को सरणी इंस्टेंस में परिवर्तित करने और आउटपुट का निरीक्षण करने के लिए उपयोग कर सकते हैं ।

— पाओलो मोरेट्टी

Answer 16

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

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 a-b})}

Comments

लघु! = सरल, लेकिन सरल बेहतर है। यहाँ संस्करण पढ़ना आसान है: const range = (a, b) => (a>=b) ? [] : [a, ...range(a+1, b)]ES6 सिंटैक्स

— nafg

@nafg: const range = (a, b, Δ = 1) => (a > b) ? [] : [a, ...range(a + Δ, b, Δ)];। साथ ही कमेंट के लिए पूरे जवाब को अपटूडेट किया।

— 7vujy0f0hy

Answer 17

यह सबसे अच्छा तरीका नहीं हो सकता है। लेकिन अगर आप कोड की एक पंक्ति में संख्याओं की एक सीमा प्राप्त करना चाहते हैं। उदाहरण के लिए 10 - 50

Array(40).fill(undefined).map((n, i) => i + 10)

जहां 40 (अंत - प्रारंभ) है और 10 प्रारंभ है। यह लौटना चाहिए [१०, ११, ..., ५०]

Answer 18

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

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]

Answer 19

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

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

Comments

एक साइड नोट के रूप में, मैंने एक Gist बनाया है जिसमें मैंने एक "संवर्धित" getRange()प्रकार का कार्य किया है। विशेष रूप से, मैंने किनारे के मामलों को पकड़ने का लक्ष्य रखा है जो ऊपर के नंगे हड्डियों वाले संस्करण में अनसुना हो सकते हैं। इसके अतिरिक्त, मैंने अल्फ़ान्यूमेरिक पर्वतमाला के लिए समर्थन जोड़ा। दूसरे शब्दों में, इसे दो आपूर्ति किए गए इनपुटों के साथ कॉल करना ( जैसे 'C'और 'K'उस क्रम में) एक सरणी देता है जिसके मान अक्षर 'C' (समावेशी) अक्षर 'K' (अनन्य) से वर्णों के अनुक्रमिक सेट होते हैं:getRange('C', 'K'); // => ["C", "D", "E", "F", "G", "H", "I", "J"]

— IsenrichO

आपको newकीवर्ड की आवश्यकता नहीं है

— Soldeplata Saketos

Answer 20

range(start,end,step): ईएस 6 इटरेटर के साथ

आप केवल ऊपरी और निचले सीमा के लिए पूछें। यहां हम एक कदम के साथ एक भी बनाते हैं।

आप आसानी से range()जनरेटर फ़ंक्शन बना सकते हैं जो एक पुनरावृत्त के रूप में कार्य कर सकता है। इसका मतलब है कि आपको संपूर्ण सरणी को पूर्व-उत्पन्न करने की आवश्यकता नहीं है।

function * range ( start, end, step = 1 ) {
  let state = start;
  while ( state < end ) {
    yield state;
    state += step;
  }
  return;
};

अब आप कुछ ऐसा बनाना चाहते हैं जो पुनरावृत्त को सरणी से पूर्व उत्पन्न करता है और एक सूची देता है। यह उन कार्यों के लिए उपयोगी है जो एक सरणी को स्वीकार करते हैं। इसके लिए हम उपयोग कर सकते हैंArray.from()

const generate_array = (start,end,step) =>
  Array.from( range(start,end,step) );

अब आप आसानी से स्थैतिक सरणी उत्पन्न कर सकते हैं,

const array1 = generate_array(1,10,2);
const array1 = generate_array(1,7);

लेकिन जब कुछ एक पुनरावृत्ति की इच्छा करता है (या आपको पुनरावृत्त का उपयोग करने का विकल्प देता है) तो आप आसानी से एक भी बना सकते हैं।

for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {
  console.log(i)
}

विशेष टिप्पणीया

• आप का उपयोग करते हैं Ramda, वे अपने स्वयं के हैR.range करता है Lodash

Answer 21

हालांकि यह 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] 

Comments

सबसे तेज के लिए +1। -36768 - 36768 के सरणी के साथ, 3ms लिया, दूसरा स्थान 13 एमएस था और इसमें आईडीई लाल रेखाएं हैं।

— mjwrazor

Answer 22

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

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]

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

Comments

array = []लूप के अंदर सेटिंग आपको वह नहीं दे सकती जो आप चाहते हैं।

— एलेक्स

@alex, धन्यवाद। आप सही कह रहे हैं, मैं लूप के प्रत्येक पास पर "स्टार्ट" पैरामीटर को बढ़ाना भी भूल गया। यह अब तय हो गया है।

— jhaskell

यह अभी भी वांछित उत्पादन नहीं करेगा, अगर मुझे 5-10 की रेंज चाहिए, तो यह मुझे देगा [5, 6, 7, 8, 9, 10, 11, 12, 13, 14], मैं उस सरणी के पहले आधे हिस्से की अपेक्षा करूंगा।

— एलेक्स

@alex, फिर से धन्यवाद, मैंने इनपुट के आधार पर एक लंबाई की कमी पर विचार नहीं किया था। अद्यतन संस्करण देखें।

— jhaskell

Answer 23

का उपयोग करते हुए सद्भाव जनरेटर , 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 नहीं neccesary

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

रिटर्न

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

सभी को ले

उदाहरण 3।

from नहीं neccesary

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

Comments

मेरे सुझावों के साथ संपादित :)

— Xotic750

दृष्टिकोण के लिए +1। @ एलेक्स की बात के लिए, forखंड में टर्नरी संचालन (विशेष रूप से नेस्टेड नहीं) होने से यहां पठनीयता में सुधार होगा।

— जस्टिन जॉनसन

Answer 24

... अधिक रेंज, एक जनरेटर फ़ंक्शन का उपयोग करके।

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++
    }
  }
  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 % 2) ? acc.concat(c) : acc, []))

// ... etc, etc.

आशा है कि यह उपयोगी है।

Answer 25

मेरा कोडगॉर्फ़िंग सहकर्मी इस (ES6) के साथ आया, समावेशी:

(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)

गैर समावेशी:

(s,f)=>[...Array(f-s)].map((e,i)=>i+s)

Answer 26

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

Answer 27

d3 में एक अंतर्निहित रेंज फ़ंक्शन भी है। 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]

Comments

मुझे कभी नहीं पता था कि डी 3 मौजूद है। उनकी श्रेणी पद्धति का उपयोग करने के लिए नहीं बल्कि इस पैकेज का उपयोग करने के लिए।

— mjwrazor

बहुत बहुत धन्यवाद। मैं डी 3 का उपयोग करता हूं और एक देशी जेएस विधि की तलाश में था, यह नहीं जानते हुए कि मैं डी 3 पहले से ही प्रदान करता है।

— Cezar

Answer 28

सीमा ([प्रारंभ, रोकें [, कदम]) हस्ताक्षर का उपयोग करके पूर्ण 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((e-b)/step)), (_,i) => b<e? b+i*step : b-i*step)
}

यदि आपके पास पाओलो मोरेटी के जनरेटर दृष्टिकोण पर बड़ी रेंज है

Comments

बदलें !stopके साथ typeof stop === 'undefined', तो बदलने के intसाथ Math.floor, और एक जांच जोड़ने if (start > stop && step > 0)(अन्यथा, range(-3, -10)बजाय कुछ समझदार कर (या तो कदम का संकेत flipping या लौटने का एक अपवाद फेंकता है []))। नहीं तो अच्छा!

— अहमद फ़सीह

Answer 29

उसके लिए एक npm मॉड्यूल bereich है ("bereich" "रेंज" के लिए जर्मन शब्द है)। यह आधुनिक जावास्क्रिप्ट के पुनरावृत्तियों का उपयोग करता है, इसलिए आप इसे विभिन्न तरीकों से उपयोग कर सकते हैं, जैसे:

console.log(...bereich(1, 10));
// => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

const numbers = Array.from(bereich(1, 10));
// => [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

for (const number of bereich(1, 10)) {
  // ...
}

यह अवरोही श्रेणियों (बस विनिमय minकरके max) का भी समर्थन करता है, और यह इसके अलावा अन्य चरणों का भी समर्थन करता है 1।

डिस्क्लेमर: मैं इस मॉड्यूल का लेखक हूं, इसलिए कृपया मेरे उत्तर को नमक के दाने के साथ लें।

Answer 30

यह एक काम उल्टा भी करता है।

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

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