.map () एक जावास्क्रिप्ट ES6 मानचित्र?

Question 1

आप यह कैसे करेंगे? सहज रूप से, मैं करना चाहता हूं:

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

// wishful, ignorant thinking
var newMap = myMap.map((key, value) => value + 1); // Map { 'thing1' => 2, 'thing2' => 3, 'thing3' => 4 }

मैंने नए पुनरावृत्ति प्रोटोकॉल पर प्रलेखन से बहुत अधिक चमक नहीं ली है ।

मैं के बारे में पता कर रहा हूँ wu.js , लेकिन मैं एक चल रहा हूँ कोलाहल परियोजना और नहीं शामिल करना चाहते हैं Traceur है, जो ऐसा लगता है जैसे कि यह वर्तमान पर निर्भर करता है ।

मैं थोड़ा क्लूलेस भी हूं कि कैसे फिटज़ेन / wu.js को निकालने के लिए इसे मैंने अपने प्रोजेक्ट में किया।

मैं यहाँ क्या याद कर रहा हूँ की एक स्पष्ट, संक्षिप्त विवरण प्यार करता हूँ। धन्यवाद!

ES6 मानचित्र , FYI के लिए डॉक्स

Question 2

तो .mapखुद को केवल एक मूल्य प्रदान करता है जिसकी आपको परवाह है ... उस ने कहा, इससे निपटने के कुछ तरीके हैं:

// instantiation
const myMap = new Map([
  [ "A", 1 ],
  [ "B", 2 ]
]);

// what's built into Map for you
myMap.forEach( (val, key) => console.log(key, val) ); // "A 1", "B 2"

// what Array can do for you
Array.from( myMap ).map(([key, value]) => ({ key, value })); // [{key:"A", value: 1}, ... ]

// less awesome iteration
let entries = myMap.entries( );
for (let entry of entries) {
  console.log(entry);
}

ध्यान दें, मैं उस दूसरे उदाहरण में बहुत सारे नए सामान का उपयोग कर रहा हूं ... ... Array.fromकोई भी पुनरावृत्ति लेता है (किसी भी समय आप उपयोग करेंगे [].slice.call( ), प्लस सेट और मैप्स) और इसे एक सरणी में बदल देता है ... ... मैप्स , जब एक सरणी में coerced, सरणियों की एक सरणी में बदल जाते हैं, जहां el[0] === key && el[1] === value;(मूल रूप से, एक ही प्रारूप में कि मैं अपने उदाहरण के साथ मैप किया था, ऊपर)।

मैं लैंबडा की तर्क स्थिति में सरणी के विनाश का उपयोग कर रहा हूं, प्रत्येक ए एल के लिए एक ऑब्जेक्ट वापस करने से पहले उन एरे स्पॉट को मूल्यों पर नियत करने के लिए।

यदि आप उत्पादन में बैबेल का उपयोग कर रहे हैं, तो आपको बैबेल के ब्राउज़र पॉलीफिल (जिसमें "कोर-जेएस" और फेसबुक के "रीजनरेटर" शामिल हैं) का उपयोग करने की आवश्यकता है।
मैं इसमें शामिल हूं Array.from।

Question 3

आपको बस स्प्रेड ऑपरेटर का उपयोग करना चाहिए :

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

var newArr = [...myMap].map(value => value[1] + 1);
console.log(newArr); //[2, 3, 4]

var newArr2 = [for(value of myMap) value = value[1] + 1];
console.log(newArr2); //[2, 3, 4]

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

Question 4

बस उपयोग करें Array.from(iterable, [mapFn])।

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

var newArr = Array.from(myMap.values(), value => value + 1);

Question 5

आप इस फ़ंक्शन का उपयोग कर सकते हैं:

function mapMap(map, fn) {
  return new Map(Array.from(map, ([key, value]) => [key, fn(value, key, map)]));
}

उपयोग:

var map1 = new Map([["A", 2], ["B", 3], ["C", 4]]);

var map2 = mapMap(map1, v => v * v);

console.log(map1, map2);
/*
Map { A → 2, B → 3, C → 4 }
Map { A → 4, B → 9, C → 16 }
*/

Question 6

का उपयोग करते हुए Array.fromमैंने लिखा एक टाइपप्रति समारोह है कि मूल्यों के नक्शे:

function mapKeys<T, V, U>(m: Map<T, V>, fn: (this: void, v: V) => U): Map<T, U> {
  function transformPair([k, v]: [T, V]): [T, U] {
    return [k, fn(v)]
  }
  return new Map(Array.from(m.entries(), transformPair));
}

const m = new Map([[1, 2], [3, 4]]);
console.log(mapKeys(m, i => i + 1));
// Map { 1 => 3, 3 => 5 }

Question 7

वास्तव में आप अभी भी Mapसरणी के साथ परिवर्तित करने के बाद मूल कुंजी के साथ कर सकते हैं Array.from। यह एक ऐरे को वापस करके संभव है , जहां पहला आइटम है key, और दूसरा ट्रांसफ़ॉर्म किया गया है value।

const originalMap = new Map([
  ["thing1", 1], ["thing2", 2], ["thing3", 3]
]);

const arrayMap = Array.from(originalMap, ([key, value]) => {
    return [key, value + 1]; // return an array
});

const alteredMap = new Map(arrayMap);

console.log(originalMap); // Map { 'thing1' => 1, 'thing2' => 2, 'thing3' => 3 }
console.log(alteredMap);  // Map { 'thing1' => 2, 'thing2' => 3, 'thing3' => 4 }

यदि आप पहले सरणी आइटम के रूप में उस कुंजी को वापस नहीं करते हैं , तो आप अपनी Mapचाबियाँ ढीली करते हैं ।

Question 8

मैं मानचित्र का विस्तार करना पसंद करता हूं

export class UtilMap extends Map {  
  constructor(...args) { super(args); }  
  public map(supplier) {
      const mapped = new UtilMap();
      this.forEach(((value, key) => mapped.set(key, supplier(value, key)) ));
      return mapped;
  };
}

Question 9

आप मूल्य बदलने के लिए map.set का उपयोग करके myMap.forEach और प्रत्येक लूप में उपयोग कर सकते हैं।

myMap = new Map([
  ["a", 1],
  ["b", 2],
  ["c", 3]
]);

for (var [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value);
}


myMap.forEach((value, key, map) => {
  map.set(key, value+1)
})

for (var [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value);
}

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

Question 10

const mapMap = (callback, map) => new Map(Array.from(map).map(callback))

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

var newMap = mapMap((pair) => [pair[0], pair[1] + 1], myMap); // Map { 'thing1' => 2, 'thing2' => 3, 'thing3' => 4 }

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

Question 11

यदि आप संपूर्ण मानचित्र को पहले से किसी सरणी में बदलना नहीं चाहते हैं, और / या विनाश कुंजी-मूल्य सरणियों में, आप इस मूर्खतापूर्ण फ़ंक्शन का उपयोग कर सकते हैं:

/**
 * Map over an ES6 Map.
 *
 * @param {Map} map
 * @param {Function} cb Callback. Receives two arguments: key, value.
 * @returns {Array}
 */
function mapMap(map, cb) {
  let out = new Array(map.size);
  let i = 0;
  map.forEach((val, key) => {
    out[i++] = cb(key, val);
  });
  return out;
}

let map = new Map([
  ["a", 1],
  ["b", 2],
  ["c", 3]
]);

console.log(
  mapMap(map, (k, v) => `${k}-${v}`).join(', ')
); // a-1, b-2, c-3

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

Question 12

Map.prototype.map = function(callback) {
  const output = new Map()
  this.forEach((element, key)=>{
    output.set(key, callback(element, key))
  })
  return output
}

const myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]])
// no longer wishful thinking
const newMap = myMap.map((value, key) => value + 1)
console.info(myMap, newMap)

संपादन प्रोटोटाइप से बचने में अपने धार्मिक उत्साह पर निर्भर करता है, लेकिन, मुझे लगता है कि यह मुझे सहज रखने देता है।

Question 13

आप मैप () एरेज़ कर सकते हैं, लेकिन मैप्स के लिए ऐसा कोई ऑपरेशन नहीं है। डॉ। एक्सल रस्शमेयर से समाधान :

नक्शे को [कुंजी, मान] जोड़े की एक सरणी में बदलें।
सरणी को मैप या फ़िल्टर करें।
परिणाम को मानचित्र में वापस कनवर्ट करें।

उदाहरण:

let map0 = new Map([
  [1, "a"],
  [2, "b"],
  [3, "c"]
]);

const map1 = new Map(
  [...map0]
  .map(([k, v]) => [k * 2, '_' + v])
);

परिणामस्वरूप

{2 => '_a', 4 => '_b', 6 => '_c'}

Question 14

शायद इस तरह:

const m = new Map([["a", 1], ["b", 2], ["c", 3]]);
m.map((k, v) => [k, v * 2]); // Map { 'a' => 2, 'b' => 4, 'c' => 6 }

आपको पहले केवल बन्दर पैच की आवश्यकता होगी Map:

Map.prototype.map = function(func){
    return new Map(Array.from(this, ([k, v]) => func(k, v)));
}

हम इस पैच का एक सरल रूप लिख सकते हैं:

Map.prototype.map = function(func){
    return new Map(Array.from(this, func));
}

लेकिन हम हमें उस समय लिखने के लिए मजबूर कर देते थे m.map(([k, v]) => [k, v * 2]);जो मुझे थोड़ा अधिक दर्दनाक और बदसूरत लगता है।

केवल मैपिंग मान

हम केवल मूल्यों को मैप कर सकते हैं, लेकिन मैं उस समाधान के लिए जाने की सलाह नहीं दूंगा क्योंकि यह बहुत विशिष्ट है। फिर भी यह किया जा सकता है और हमारे पास निम्नलिखित एपीआई होंगे:

const m = new Map([["a", 1], ["b", 2], ["c", 3]]);
m.map(v => v * 2); // Map { 'a' => 2, 'b' => 4, 'c' => 6 }

इस तरह पैच करने से पहले:

Map.prototype.map = function(func){
    return new Map(Array.from(this, ([k, v]) => [k, func(v)]));
}

हो सकता है कि आपके पास दोनों हों, दूसरे mapValuesका नामकरण यह स्पष्ट करने के लिए कि आप वास्तव में ऑब्जेक्ट की मैपिंग नहीं कर रहे हैं क्योंकि यह संभवतः अपेक्षित होगा।