.map() 자바스크립트 ES6 지도?

.map() 자바스크립트 ES6 지도?

어떻게 하실 겁니까?본능적으로 저는 다음과 같이 하고 싶습니다.

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를 포함하고 싶지 않습니다.

또한 fitzgen/wu.js가 어떻게 내 프로젝트에서 그것을 했는지를 어떻게 추출할지에 대해서는 조금 혼란스럽습니다.

제가 여기서 놓치고 있는 것에 대한 명확하고 간결한 설명을 듣고 싶습니다.감사합니다!

---

ES6 Map, FYI용 문서

그렇게.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( ), 그리고 세트 및 맵)을 선택하여 배열로 바꿉니다.지도를 배열로 강제화하면 배열 배열로 바뀝니다.el[0] === key && el[1] === value;(기본적으로 위에서 예제 맵을 미리 작성한 것과 동일한 형식으로).

저는 각 el에 대한 객체를 반환하기 전에 람다의 인수 위치에서 배열 파괴를 사용하여 배열 스폿을 값에 할당합니다.

Babel을 사용하는 경우 프로덕션에서 Babel의 브라우저 폴리필("core-js"와 Facebook의 "regenerator"를 포함)을 사용해야 합니다.
그 안에 들어있을 거라고 확신해요.Array.from.

그냥 사용.Array.from(iterable, [mapFn]).

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

var newEntries = Array.from(myMap, ([key, value]) => [key, value + 1]);
var newMap = new Map(newEntries);

스프레드 연산자를 사용해야 합니다.

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]

다음 기능을 사용할 수 있습니다.

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 }
*/

누군가가 필요할 경우를 대비해서 타이프스크립트:

export {}

declare global {
    interface Map<K, V> {
        map<T>(predicate: (key: K, value: V) => T): Map<V, T>
    }
}

Map.prototype.map = function<K, V, T>(predicate: (value: V, key: K) => T): Map<K, T> {
    let map: Map<K, T> = new Map()

    this.forEach((value: V, key: K) => {
        map.set(key, predicate(value, key))
    })
    return map
}

사용.Array.from값을 매핑하는 Typescript 함수를 작성했습니다.

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 }

사실은 아직도 당신은.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열쇠들.

배열을 매핑()할 수 있지만 맵에 대한 이러한 작업은 없습니다.박사님의 해결책. 악셀 라우슈메이어:

• 맵을 [키, 값] 쌍의 배열로 변환합니다.
• 배열을 매핑하거나 필터링합니다.
• 결과를 지도로 다시 변환합니다.

예:

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

나는 지도를 확장하는 것을 선호합니다.

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

맵을 이용하여 각각의 루프에서 myMap.을 사용할 수 있습니다.값을 변경하도록 설정합니다.

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

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 }

전체 맵을 미리 배열로 변환하거나 키 값 배열을 구조화하지 않으려면 다음과 같은 어리석은 기능을 사용할 수 있습니다.

/**
 * 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

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)

프로토타입 편집을 피하는 당신의 종교적 열정에 따라 다르겠지만, 저는 이것이 직관적으로 유지할 수 있게 해준다고 생각합니다.

다음은 기존 아이디어 중 일부를 기반으로 하여 다음과 같은 방식으로 유연성을 갖추려는 Typescript 변형입니다.

• 출력 맵의 키 및 값 유형이 모두 입력과 다를 수 있습니다.
• 맵퍼 기능은 원할 경우 입력 맵 자체에 접근할 수 있습니다.

function mapMap<TKI, TVI, TKO, TVO>(map: Map<TKI, TVI>,
        f: (k: TKI, v: TVI, m: Map<TKI, TVI>) => [TKO, TVO]) : Map<TKO, TVO>{
    return new Map([...map].map(p => f(p[0], p[1], map)))
}

참고: 이 코드는 기존 아이디어 중 일부와 마찬가지로 스프레드 연산자를 사용하므로 대상이 필요합니다.of 'es2015' or higher내 VS 코드 인텔리전스에 따르면.

이런 식일 수도 있습니다.

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]);제가 보기엔 좀 더 고통스럽고 추한 것 같아요

값 매핑만

값을 매핑할 수도 있지만, 그 솔루션은 너무 구체적이기 때문에 사용하는 것은 권장하지 않습니다.그럼에도 불구하고 할 수 있고 우리는 다음과 같은 API를 갖게 될 것입니다.

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개체를 실제로 매핑하는 것이 아님을 분명히 하기 위해 개체를 예상되는 대로 매핑합니다.

언급URL : https://stackoverflow.com/questions/31084619/map-a-javascript-es6-map