एक पुनरावृत्ति पर मानचित्र () का उपयोग करना

Question 1

मान लें कि हमारे पास एक मानचित्र है: रिटर्न let m = new Map();का उपयोग करके m.values()एक मानचित्र पुनरावृत्ति।

लेकिन मैं उस पुनरावृत्त पर forEach()या map()उस समय का उपयोग नहीं कर सकता और उस पुनरावृत्ति पर थोड़ी देर के लूप को लागू करना ईएस 6 प्रस्ताव कार्यों की तरह विरोधी पैटर्न की तरह लगता है map()।

तो क्या map()एक पुनरावृत्ति पर उपयोग करने का एक तरीका है?

Question 2

ऐसा करने का सबसे सरल और सबसे कम तरीका है:

Array.from(m).map(([key,value]) => /* whatever */)

और भी बेहतर

Array.from(m, ([key, value]) => /* whatever */))

Array.fromकिसी भी चलने योग्य या सरणी जैसी चीज़ को लेता है और इसे एक सरणी में परिवर्तित करता है! जैसा कि डैनियल टिप्पणियों में बताते हैं, हम एक पुनरावृत्ति को हटाने के लिए रूपांतरण और बाद में एक मध्यवर्ती सरणी में एक मैपिंग फ़ंक्शन जोड़ सकते हैं।

का उपयोग Array.fromकर अपने प्रदर्शन से O(1)के O(n)रूप में @hraban टिप्पणियों में बताते हैं। चूंकि mएक है Map, और वे अनंत नहीं हो सकते हैं, हमें अनंत अनुक्रम के बारे में चिंता करने की आवश्यकता नहीं है। अधिकांश उदाहरणों के लिए, यह पर्याप्त होगा।

मानचित्र के माध्यम से लूप करने के अन्य तरीके हैं।

का उपयोग करते हुए `forEach`

m.forEach((value,key) => /* stuff */ )

का उपयोग करते हुए `for..of`

var myMap = new Map();
myMap.set(0, 'zero');
myMap.set(1, 'one');
for (var [key, value] of myMap) {
  console.log(key + ' = ' + value);
}
// 0 = zero
// 1 = one

Question 3

आप इस पर लूप करने के लिए एक और पुनरावृत्ति फ़ंक्शन को परिभाषित कर सकते हैं:

function* generator() {
    for (let i = 0; i < 10; i++) {
        console.log(i);
        yield i;
    }
}

function* mapIterator(iterator, mapping) {
    for (let i of iterator) {
        yield mapping(i);
    }
}

let values = generator();
let mapped = mapIterator(values, (i) => {
    let result = i*2;
    console.log(`x2 = ${result}`);
    return result;
});

console.log('The values will be generated right now.');
console.log(Array.from(mapped).join(','));

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

अब आप पूछ सकते हैं: क्यों नहीं Array.fromइसके बजाय का उपयोग करें ? क्योंकि यह पूरे पुनरावृत्त के माध्यम से चलेगा, इसे एक (अस्थायी) सरणी में सहेजें, इसे फिर से पुनरावृत्त करें और फिर मैपिंग करें। यदि सूची बहुत बड़ी है (या संभावित रूप से अनंत) तो यह अनावश्यक मेमोरी उपयोग को बढ़ावा देगा।

बेशक, यदि वस्तुओं की सूची काफी छोटी है, तो उपयोग Array.fromपर्याप्त से अधिक होना चाहिए।

Question 4

यह सबसे सरल और सबसे अच्छा तरीका है कि Array.fromइसे प्राप्त करने के लिए दूसरे तर्क का उपयोग करें:

const map = new Map()
map.set('a', 1)
map.set('b', 2)

Array.from(map, ([key, value]) => `${key}:${value}`)
// ['a:1', 'b:2']

यह दृष्टिकोण किसी भी गैर-अनंत पुनरावृत्ति के लिए काम करता है । और यह एक अलग कॉल का उपयोग करने से बचता है, Array.from(map).map(...)जो पुनरावृत्ति के माध्यम से दो बार पुनरावृत्ति करेगा और प्रदर्शन के लिए बदतर होगा।

Question 5

आप पुनरावृत्त पर एक पुनरावृत्ति प्राप्त कर सकते हैं, फिर एक और पुनरावृत्ति लौटाते हैं जो प्रत्येक पुनरावृत्त तत्व पर मैपिंग कॉलबैक फ़ंक्शन को कॉल करता है।

const map = (iterable, callback) => {
  return {
    [Symbol.iterator]() {
      const iterator = iterable[Symbol.iterator]();
      return {
        next() {
          const r = iterator.next();
          if (r.done)
            return r;
          else {
            return {
              value: callback(r.value),
              done: false,
            };
          }
        }
      }
    }
  }
};

// Arrays are iterable
console.log(...map([0, 1, 2, 3, 4], (num) => 2 * num)); // 0 2 4 6 8

Question 6

आप itiriri का उपयोग कर सकते हैं जो iterables के लिए सरणी जैसी विधियों को लागू करता है:

import { query } from 'itiriri';

let m = new Map();
// set map ...

query(m).filter([k, v] => k < 10).forEach([k, v] => console.log(v));
let arr = query(m.values()).map(v => v * 10).toArray();

Question 7

पर एक नज़र डालें Https://www.npmjs.com/package/fluent-iterable

सभी iterables के साथ काम करता है (नक्शा, जनरेटर समारोह, सरणी) और async iterables।

const map = new Map();
...
console.log(fluent(map).filter(..).map(..));

Question 8

एक प्रस्ताव है, जो कई सहायक कार्य ला रहा है Iterator: https://github.com/tc39/proposal-iterator-helpers ( प्रस्तुत किया गया )

आप इसका आज उपयोग करके उपयोग कर सकते हैं core-js:

import { from as iterFrom } from "core-js-pure/features/iterator";

// or if it's working for you:
// import iterFrom from "core-js-pure/features/iterator/from";

let m = new Map();

m.set("13", 37);
m.set("42", 42);

const arr = iterFrom(m.values())
  .map((val) => val * 2)
  .toArray();

// prints "[74, 84]"
console.log(arr);

Question 9

यहाँ अन्य उत्तर हैं ... अजीब। वे पुनरावृत्ति प्रोटोकॉल के कुछ हिस्सों को फिर से लागू कर रहे हैं। आप ऐसा कर सकते हैं:

function* mapIter(iterable, callback) {
  for (let x of iterable) {
    yield callback(x);
  }
}

और यदि आप एक ठोस परिणाम चाहते हैं तो बस प्रसार ऑपरेटर का उपयोग करें ...।

[...iterMap([1, 2, 3], x => x**2)]

एक पुनरावृत्ति पर मानचित्र () का उपयोग करना

का उपयोग करते हुए forEach

का उपयोग करते हुए for..of

का उपयोग करते हुए `forEach`

का उपयोग करते हुए `for..of`