পাইথন রেঞ্জের মতো জাভাস্ক্রিপ্ট ফাংশন ()

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

2018: এই উত্তরটি অগ্রগতি পেতে চলেছে, তাই এখানে একটি আপডেট। নীচের কোডটি অচল, তবে ভাগ্যক্রমে ES6 স্ট্যান্ডার্ডাইজড জেনারেটর এবং yieldকীওয়ার্ড এবং সেগুলি প্ল্যাটফর্ম জুড়ে সর্বজনীনভাবে সমর্থনযোগ্য। অলস range()ব্যবহার করে উদাহরণ yieldপাওয়া যায় এখানে ।

ইতিমধ্যে যা বলা হয়েছে তা ছাড়াও জাভাস্ক্রিপ্ট ১.7+ পুনরাবৃত্তিকারী এবং জেনারেটরের জন্য সমর্থন সরবরাহ করে যা rangeপাইথন 2 তে সিমলার এর একটি অলস, স্মৃতি-দক্ষ সংস্করণ তৈরি করতে ব্যবহার করা যেতে পারে 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

@ টেডেক এবং @ জর্জের উভয় উত্তর একসাথে ফিউজ করে , আমি এটি নিয়ে এসেছি:

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

@ টেডেকের @ বিপরীতে , @ ভলভ এবং @ জানকা 102 এর উত্তর যা ফিরে আসে [], 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, তাই এক এক liners, মত অভিনব কাজ করতে পারে:

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

প্রকাশ আমি পাইথোনিকের লেখক এবং রক্ষণাবেক্ষণকারী

Question 14

এমডিএন এই পদ্ধতির প্রস্তাব দেয়: সিকোয়েন্স জেনারেটর (পরিসর)

// 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 এ, ব্যাপ্তি () পদ্ধতিটি একটি পুনরাবৃত্তিকে দেয়। জাভাস্ক্রিপ্টে পুনরুক্তি রয়েছে এবং তারা পুরো অ্যারে তৈরি করে এবং স্মৃতিতে এটি সঞ্চয় করার চেয়ে আরও বেশি জায়গা দক্ষ efficient

সুতরাং পাইথন 3 এর range(n)কার্যকারিতাটির আরও নিখুঁত প্রতিনিধিত্ব Array(n).keys()।

উদাহরণ স্বরূপ:

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

আরও একটি উদাহরণ (যা ইতিমধ্যে অন্যান্য উত্তরে coveredাকা পড়েছে)। পুনরাবৃত্তিকে একটি অ্যারেতে রূপান্তর করা (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সম্পত্তি দিয়ে একটি সরল অবজেক্টে পাস করা একটি অ্যারেআইটরেটর তৈরি করবে যা 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 এর জন্য একটি আকর্ষণীয় পদ্ধতির। এটি পাইথন ২.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

নোডজেসের জন্য একটি বিকল্প হল বাফার ব্যবহার করা:

[...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()`জাভাস্ক্রিপ্ট এবং পাইথনের মধ্যে তুলনা