সরবরাহের সীমানার মধ্যে একটি পরিসীমা তৈরির জন্য জাভা স্ক্রিপ্টের কি "রেঞ্জ ()" এর মতো কোনও পদ্ধতি আছে?

Question

পিএইচপি-তে আপনি করতে পারেন ...

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

এটি হ'ল একটি ফাংশন রয়েছে যা আপনাকে উপরের এবং নীচের সীমাটি পেরিয়ে একাধিক সংখ্যা বা অক্ষর পেতে দেয়।

এর জন্য জাভাস্ক্রিপ্টে অন্তর্নির্মিত কিছু রয়েছে? তা না হলে আমি কীভাবে এটি বাস্তবায়ন করব?

Comments

প্রোটোটাইপ.জেএস এর $Rফাংশন রয়েছে তবে এর বাইরে আমি সত্যিই এটি ভাবি না।

— ই জিয়াং

এই (সম্পর্কিত) প্রশ্নের কয়েকটি দুর্দান্ত উত্তর রয়েছে: স্ট্যাকওভারফ্লো.com

— বিটি কে

Array.from("ABC") //['A', 'B', 'C']এই প্রশ্নের দ্বিতীয় অংশের জন্য আমি খুঁজে পেতে পারি এটি সবচেয়ে কাছের জিনিস।

— অ্যান্ড্রু_1510

@ অ্যান্ড্রু_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"

পুরাতন নন এস 6 ব্রাউজারগুলি লাইব্রেরি ছাড়াই:

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

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

(নীল পিটারসোহন এবং অন্যান্য মন্তব্যকারীদের ES6 ক্রেডিট)

Comments

কারণ এটি যে কোনও জায়গায় কার্যকর হলে এটি সম্ভবত জেএসে কার্যকর। (জাতীয় কার্যকরী প্রোগ্রামিং টাইপ কাপড়, যা একটি পরিসীমা থেকে উপকৃত হতে পারেন (0 বিবৃতি যে কাজ করতে পারেন এবং এক হাজার অন্যান্য কারণে এটি কিছু semirare ক্ষেত্রে উপযোগী হতে পারে)।

— Lodewijk

কোনও ধারণা কেন কেবল ব্যবহার করে (new Array(5)).map(function (value, index) { return index; })কাজ হবে না? এটি [undefined × 5]আমার জন্য ক্রোম দেবটুলগুলিতে ফিরে আসে ।

— লুইস

@ লুইস কারণ এর সাথে সংজ্ঞায়িত একটি অ্যারেতে খালি স্লট রয়েছে যা এর সাথে map()বা তার কোনও বন্ধুর সাথে পুনরাবৃত্তি হবে না ।

— অ্যালেক্স

অ্যারে.ফ্রোম (অ্যারে (5) .কিজ ())

— নিল পিটারসোহন

Array(5).fill()এছাড়াও

— ম্যাপেবল

Answer 2

সংখ্যার জন্য আপনি ES6 ব্যবহার করতে পারেন Array.from(), যা বর্তমানে আইই ব্যতীত সমস্ত কিছুতে কাজ করে :

সংক্ষিপ্ত সংস্করণ:

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) .কিজ ()]

— ডেলাপুইট

Array.from()পদ্ধতির চেয়ে কিছুটা সামান্য কম এবং উভয়ের চেয়ে দ্রুত:Array(20).fill().map((_, i) => i)

— স্টু কক্স

পছন্দ করুন আপনার এটি পৃথক উত্তর করা উচিত, এবং আমি এটির জন্য ভোট দেব! এটি এই সদৃশটির সঠিক উত্তরও ।

— jib

@ ডেলাপুইট @ জিব এবং এটিও:Array.from({length: end - start}, (v, k) => k + start)

— আদিত্য সিংহ

@ আইসিসি ৯7 হ্যাঁ, লিটাররা অভিযোগ করতে পারে, যদিও জাভাস্ক্রিপ্টে কোনও ফাংশন আর্গুমেন্ট বাদ দিয়ে একইরূপে সংজ্ঞায়িত করা হয়েছে 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আসলে থামার / শেষের অবস্থান নয় তবে গণনা / দূরত্ব। (কোনও অপরাধ নয়, কেবল টাইপো সম্পর্কে মানুষকে সচেতন করার জন্য)

— এফ লেকচাস

বিভ্রান্তির জন্য - এফ লেকশাসের মন্তব্যের পরে রডফারসোর সম্পাদনার কারণে, তার কোডটি এখন সঠিক।

— এদরাহ

আপনি যে যুক্তিটি Array(Math.ceil((stop - start) / step) + 1)দিয়ে +1গেছেন, শেষ পর্যন্ত পিএইচপি'র "অন্তর্ভুক্ত" আচরণের অনুকরণ করতে হবে।

— জোহান ডেটমার

এটি শীর্ষস্থানীয় উত্তর যা জাভাস্ক্রিপ্ট ফাংশনের পুরো প্রশ্নের উত্তর দেয় যা পুরোপুরি কোনও rangeপদ্ধতি প্রয়োগ করে । বর্তমানে এর উপরে থাকা অন্য সমস্ত (লোড্যাশ ব্যতীত _.range) শুরু, স্টপ এবং পদক্ষেপের সাথে কোনও আসল পরিসীমা ফাংশন না করে বেসিক পুনরাবৃত্তি প্রয়োগ করে

— আইসিসি

Answer 4

এখানে আমার 2 সেন্ট:

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

Comments

হাই অর্ডার ফাংশনগুলির দুর্দান্ত ব্যবহার

— ফারজাদ ওয়াইজেড

এটি আসলে ভুল কারণ প্রশ্নটি শুরু এবং শেষের মানগুলির জন্য জিজ্ঞাসা করছে। শুরু এবং গণনা / দূরত্ব নয়।

— জেমস রবি

Answer 5

এটি অক্ষর এবং সংখ্যাগুলির জন্য কাজ করে, anচ্ছিক পদক্ষেপের সাথে এগিয়ে বা পিছনে যায়।

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;

}

jsFizz ।

যদি দেশীয় প্রকারগুলি বাড়ানো আপনার জিনিস হয় তবে এটিকে নির্ধারণ করুন 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

ব্যবহারযোগ্য এবং পঠনযোগ্য জন্য প্লাস ইউএনও। আমি দীর্ঘ সময় দেখেছি সেরা কোড স্নিপেট।

— মনস্টো

যখন কাজ করে না step != 1, whileশর্ত গ্রহণ করা প্রয়োজন stepএকাউন্টে। ডিফল্ট stepমান সহ আমার আপডেট হওয়া সংস্করণ : ফাংশন সীমা (শুরু, থামানো, পদক্ষেপ) {পদক্ষেপ = পদক্ষেপ || 1 var a = [start], b = start; যখন ((বি + পদক্ষেপ) <থামুন) so কনসোল.লগ ("বি:" + বি + "। ক:" + এ + "।"); B + = ধাপ; a.push (খ); } প্রত্যাবর্তন a; }

— ডেভাহারিস 21

@ ডেভাহারিস আমি উপরে একটি ডিফল্ট পদক্ষেপ যুক্ত করেছি (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।

— কানেক্টইউরচার্জার

এই পদ্ধতিটি কেবল পূর্ণসংখ্যা এবং অক্ষরগুলির সাথে কাজ করে। পরামিতি নাল, undefined হন, নান, বুলিয়ান, অ্যারে, বস্তু ইত্যাদি এই পদ্ধতি ফেরৎ নিম্নলিখিত ত্রুটি: undefined method toUpperCase to etc!

— ভিক্টর

`` `if (typof! == 'সংখ্যার' && টাইপ থেকে! == 'স্ট্রিং') new নতুন টাইপ-এয়ার ফেলে দিন ('প্রথম প্যারামিটারটি একটি সংখ্যা বা একটি অক্ষর হওয়া উচিত')} যদি (টাইপফুড! == '' সংখ্যাটি && টাইপ করুন! == 'স্ট্রিং') new নতুন টাইপ এরির নিক্ষেপ করুন ('প্রথম প্যারামিটারটি একটি সংখ্যা বা একটি অক্ষর হওয়া উচিত')} `` `

— ভিক্টর

Answer 8

ঠিক আছে, জাভাস্ক্রিপ্টে আমাদের পিএইচপি এর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"]

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

সহজ, অবশ্যই। সরল? আমি আলাদা করতে অনুরোধ করি; নির্বিশেষে আপনি এটিকে এক লাইনার বানাচ্ছেন। পাইথন থেকে আসা এটি একটি ধাক্কা।

— পাসক্যালভিকুটেন

@ পাসকালভ কুটেন, হ্যাঁ, অবশ্যই এটি দুর্দান্ত হত যদি পাই যে পাইথনের মতো অভ্যন্তরীণ পদ্ধতিটি তৈরি করা হত তবে এটিই আমার পক্ষে আসা সহজতম উপায় ছিল। এবং এটি আমার প্রকল্পগুলিতে কার্যকর বলে প্রমাণিত হয়েছে।

— আজফরাফি

এর মতো বেদনাদায়ক জটিল কোড স্নিপেট পোস্ট করা, বিশেষত ওয়ান-লাইনার হিসাবে এবং এটি কীভাবে কাজ করে তার কোনও ব্যাখ্যা ছাড়াই? এটি "কাজ করে" তা নির্বিশেষে একটি ভাল এসও উত্তরের দুর্বল উদাহরণ ।

— ম্যাডব্রাইক

@ ম্যাডব্র্যাকস, হ্যাঁ আপনি ঠিক বলেছেন। আমি এটিকে ওয়ান লাইনার তৈরি করতে নির্বোধ হয়েছি। সবাইকে একটি দ্রুত এবং সহজ সমাধান দিতে চেয়েছিলেন

— আজেফরাতি

Answer 10

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

Comments

@ নিক্কওয়ং, _ম্যাপিং কলব্যাকের মধ্যে কেবল যুক্তির নাম। আপনি জানেন, কিছু ভাষায় আপনি _নামটি হিসাবে ভেরিয়েবলটি ব্যবহৃত হয় না তা চিহ্নিত করতে ব্যবহার করবেন।

— ক্লেসুন

এখানে যদিও, _তর্কের মধ্য দিয়ে যায় নি range। কেন না?

— নিক্ক ওয়াং

খুব ঝরঝরে! যদিও এটি গুরুত্বপূর্ণ যে এটি কোনও আইই বা অপেরাতে কাজ করে না।

— রাফায়েল জাভিয়ার

এই উত্তরটির ব্যাখ্যা প্রয়োজন, কারণ এটি এটির পক্ষে উপযুক্ত নয়।

— ম্যাডব্রেকস

@ রাফেলএক্সেভিয়ার আইআর সাথে কাজ করবে অ্যারে.ফিল () পলিফিল

— এমওয়্যাগ

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

এই ক্ষেত্রে আন্ডারস্কোর '_' প্রতীকটি কী উপস্থাপন করে?

— ওলেহ বেরেভভস্কিই

@ ওলেহবিরেহভস্কিই এর অর্থ একটি ল্যাম্বডা ফাংশন প্যারামিটার যা আপনার ব্যবহারের আসলে কোনও অভিপ্রায় নেই। অব্যবহৃত ভেরিয়েবল সম্পর্কে সতর্ক করে এমন একটি লিটার এটি এড়ানো উচিত।

— মাইকা জোল্টু

Answer 12

--- আপডেট (সরলকরণের জন্য @ লখমকভকে ধন্যবাদ) ---

ES6 জেনারেটর ব্যবহার করে অন্য একটি সংস্করণ ( ES6 জেনারেটরের সাথে দুর্দান্ত পাওলো মোরেটি উত্তর দেখুন ):

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

@lokhmakov হ্যাঁ, আপনি ঠিক বলেছেন। ধন্যবাদ! আমার উত্তরে সবেমাত্র আপনার কোড প্রয়োগ করেছেন।

— হিরো কো

Answer 13

কিছু বিভিন্ন রেঞ্জ ফাংশন নিয়ে কিছু গবেষণা করেছেন। এই ফাংশনগুলি করার বিভিন্ন উপায়ের jsperf তুলনা পরীক্ষা করে দেখুন। অবশ্যই একটি নিখুঁত বা বিস্তৃত তালিকা নয়, তবে সহায়তা করা উচিত :)

বিজয়ী...

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

প্রযুক্তিগতভাবে এটি ফায়ারফক্সের পক্ষে দ্রুততম নয়, তবে ক্রোমের পাগল গতির পার্থক্য (ইমো) এটি তৈরি করে।

এছাড়াও আকর্ষণীয় পর্যবেক্ষণ হ'ল ফায়ার ফক্সের চেয়ে এই অ্যারে ফাংশনগুলির সাথে ক্রোমটি কত দ্রুত। ক্রোম কমপক্ষে 4 বা 5 গুণ বেশি দ্রুত ।

Comments

নোট করুন যে এটি পরিসীমা ফাংশনের বিপরীতে তুলনা করা হয়েছিল যা একটি ধাপের আকারের পরামিতি অন্তর্ভুক্ত করেছে

— বাইনারিফ্যান্ট

Answer 14

স্ট্যান্ডার্ড জাভাস্ক্রিপ্টের ব্যাপ্তি তৈরি করতে অন্তর্নির্মিত ফাংশন নেই। বেশ কয়েকটি জাভাস্ক্রিপ্ট ফ্রেমওয়ার্কগুলি এই জাতীয় বৈশিষ্ট্যগুলির জন্য সমর্থন যোগ করে বা অন্যরা যেমন নির্দেশ করে যে আপনি সর্বদা নিজের রোল করতে পারেন।

আপনি যদি ডাবল-চেক করতে চান, তবে চূড়ান্ত সংস্থানটি ECMA-262 স্ট্যান্ডার্ড ।

Comments

যদিও আমি নিশ্চিত যে 2010 সালে একটি পুরোপুরি ভাল উত্তর, এটি আর সেরা পন্থা হিসাবে বিবেচনা করা উচিত নয়। প্রোটোটাইপ.জেএস এর মতো প্রকারভেদে আপনাকে প্রসারিত করা উচিত নয়

— ডানা উডম্যান

@ ডানাউইডম্যান এটি আনার জন্য ধন্যবাদ - আমি প্রোটোটাইপ.জেএস এর উল্লেখটি প্রকাশ করার জন্য উত্তরটি আপডেট করেছি যেহেতু এটি 2018 সালে সত্যিই বেশ অপ্রচলিত

— মাইক ডাইনস্কু

আচ্ছা এটি কিছুতেই সহায়তা করেনি।

— পিথিকোস

@ পিথিকোস আমি দেখতে পাচ্ছি যে এই প্রশ্নটি মূলত জিজ্ঞাসা করার পরেই সম্পাদনা করা হয়েছে এবং ওএস জেএসে কোনও দেশীয় পরিসীমা ফাংশন আছে কিনা তা জানতে চেয়েছিল।

— মাইক ডাইনস্কু

Answer 15

আপনি লোডাশ বা আনডেস্কোর.জেএস ব্যবহার করতে পারেন 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; // {} // // খালি মানচিত্রের মত লাগে! WTF !?! x.next ()। মান; // ঠিক 1; x [3] // অপরিবর্তিত, কেবল আসল অ্যারে সহ

— 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 সিনট্যাক্স ব্যবহার করে

— 7:30 এ এনএফজি

@nafg: const range = (a, b, Δ = 1) => (a > b) ? [] : [a, ...range(a + Δ, b, Δ)];। এছাড়াও মন্তব্যের জন্য পুরো উত্তর upvoting।

— 7vujy0f0hy

Answer 17

এটি সেরা উপায় নাও হতে পারে। আপনি যদি একক লাইন কোডে সংখ্যার বিস্তৃতি পেতে চাইছেন। উদাহরণস্বরূপ 10 - 50

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

যেখানে 40 হয় (শেষ - শুরু) এবং 10 শুরু is এটি ফিরে আসা উচিত [10, 11, ..., 50]

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

Array.from()স্থিতিশীল পদ্ধতির প্রতি বিশেষ মনোযোগ আকর্ষণ করে নীচে নিম্নরূপে ES6 নিয়োগ করে এমন একটি নমনীয় বাস্তবায়ন তৈরি করা যেতে পারে :

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

Comments

পার্শ্ব নোট হিসাবে, আমি একটি গিস্ট তৈরি করেছি যাতে আমি getRange()প্রকারের একটি "বর্ধিত" ফাংশন তৈরি করেছি । বিশেষত, আমি লক্ষ্য করেছি যে প্রান্তের কেসগুলি উপরের খালি-হাড়ের বৈকল্পিকের মধ্যে শোধ করা যাবে না capture অতিরিক্ত হিসাবে, আমি আলফানিউমেরিক রেঞ্জের জন্য সমর্থন যোগ করেছি। অন্য কথায়, এটিকে দুটি সরবরাহিত ইনপুটগুলির মতো কল করা 'C'এবং 'K'(সেই ক্রমে) একটি অ্যারে প্রদান করে যার মানগুলি 'সি' (অন্তর্ভুক্ত) থেকে 'কে' (এক্সক্লুসিভ) অক্ষরের মাধ্যমে অক্ষরের ক্রমিক সেট হয়:getRange('C', 'K'); // => ["C", "D", "E", "F", "G", "H", "I", "J"]

— আইসেনরিচো

আপনার newকীওয়ার্ডের দরকার নেই

— সলডেপ্লাটা সাকেটোস

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

বিশেষ নোট

• আপনি যদি রামদাR.range ব্যবহার করেন তবে লোডাশের মতো তাদেরও আছে

Answer 21

যদিও এটি পিএইচপি থেকে নয় , পাইথন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 এর অ্যারের সাথে 3 মিমি নিয়েছে, দ্বিতীয় স্থানটি 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 = []লুপের ভিতরে সেট করা আপনাকে যা চাইবে তা দিতে পারে না।

— অ্যালেক্স

@ আলেক্স, আপনাকে ধন্যবাদ আপনি ঠিক বলেছেন, আমি লুপের প্রতিটি পাসের "শুরু" পরামিতিটি বাড়িয়ে দিতে ভুলে গিয়েছিলাম। এটি এখন স্থির।

— ঝাসকেল

এটি এখনও পছন্দসই আউটপুট উত্পাদন করতে পারে না, যদি আমি 5-10 ব্যাপ্তি চাই তবে তা আমাকে দেবে [5, 6, 7, 8, 9, 10, 11, 12, 13, 14], আমি সেই অ্যারের কেবল প্রথমার্ধটি আশা করব expect

— অ্যালেক্স

@ অ্যালেক্স, আপনাকে আবারও ধন্যবাদ, আমি ইনপুটের উপর ভিত্তি করে কোনও দৈর্ঘ্যের বাধা বিবেচনা করি নি। আপডেট সংস্করণ দেখুন।

— ঝাসকেল

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 এটি যতটা পেতে পারে কেবল তা নেয় takes

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

আপনি https://lodash.com/docs#rangelodash ফাংশনটি ব্যবহার করতে পারেন_.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 এটি ইতিমধ্যে সরবরাহ করে offers

— সেজার

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)পরিবর্তে কিছু বিবেকী করছেন (হয় ধাপ চিহ্ন আলোকসম্পাতের বা ফিরে একজন ব্যতিক্রম ছোঁড়ার []))। অন্যথায়, ভাল!

— আহমেদ ফসিহ

Answer 29

তার জন্য একটি এনপিএম মডিউল বেরিচ রয়েছে ("ব্রেইচ" "রেঞ্জ" এর জার্মান শব্দ) এটি আধুনিক জাভাস্ক্রিপ্টের পুনরাবৃত্তকারীগুলির ব্যবহার করে যাতে আপনি এটি বিভিন্ন উপায়ে ব্যবহার করতে পারেন যেমন:

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 ]