Ta odpowiedź wydaje się być stronnicza i bezużyteczna w realnym świecie. Przeczytaj to tak, jak jest, i nie traktuj tego jako faktycznej opcji dla czegokolwiek innego niż eksperymentowanie

Przypadkiem użycia może być użycie go jako słownika dla słuchaczy, mam współpracownika, który to zrobił. Jest to bardzo pomocne, ponieważ każdy słuchacz jest bezpośrednio ukierunkowany na ten sposób robienia rzeczy. Żegnaj listener.on.

Ale z bardziej abstrakcyjnego punktu widzenia, WeakMap jest szczególnie potężny, aby zdematerializować dostęp do w zasadzie nic, nie potrzebujesz przestrzeni nazw, aby odizolować jej członków, ponieważ jest to już sugerowane przez naturę tej struktury. Jestem całkiem pewien, że można zrobić kilka poważnych ulepszeń pamięci, zastępując awkwards nadmiarowe klucze obiektów(nawet jeśli dekonstruowanie działa za Ciebie).

Przed przeczytaniem co dalej

Teraz zdaję sobie sprawę, że moje podkreślenie nie jest najlepszym sposobem rozwiązania problemu i jak zauważył Benjamin Gruenbaum (sprawdź jego odpowiedź, jeśli nie jest już powyżej mojego :p), ten problem nie mógłby zostać rozwiązany za pomocą zwykłego Map, ponieważ wyciekłby, a więc główną siłą WeakMap jest to, że nie koliduje z usuwaniem śmieci, biorąc pod uwagę, że nie przechowują odniesienia.

Oto prawdziwy kod mojego współpracownika (dzięki jemu za dzielenie się)

Pełne źródło tutaj, chodzi o zarządzanie słuchaczami, o którym mówiłem powyżej (możesz również spojrzeć na specs )

var listenableMap = new WeakMap();


export function getListenable (object) {
    if (!listenableMap.has(object)) {
        listenableMap.set(object, {});
    }

    return listenableMap.get(object);
}


export function getListeners (object, identifier) {
    var listenable = getListenable(object);
    listenable[identifier] = listenable[identifier] || [];

    return listenable[identifier];
}


export function on (object, identifier, listener) {
    var listeners = getListeners(object, identifier);

    listeners.push(listener);
}


export function removeListener (object, identifier, listener) {
    var listeners = getListeners(object, identifier);

    var index = listeners.indexOf(listener);
    if(index !== -1) {
        listeners.splice(index, 1);
    }
}


export function emit (object, identifier, ...args) {
    var listeners = getListeners(object, identifier);

    for (var listener of listeners) {
        listener.apply(object, args);
    }
}

WeakMap działa dobrze do enkapsulacji i ukrywania informacji

WeakMap jest dostępny tylko dla ES6 i nowszych. A WeakMap jest zbiorem par klucz i wartość, gdzie klucz musi być obiektem. W poniższym przykładzie budujemy WeakMap z dwóch elementów:

var map = new WeakMap();
var pavloHero = {first: "Pavlo", last: "Hero"};
var gabrielFranco = {first: "Gabriel", last: "Franco"};
map.set(pavloHero, "This is Hero");
map.set(gabrielFranco, "This is Franco");
console.log(map.get(pavloHero));//This is Hero

Użyliśmy metody set() do zdefiniowania asocjacji między obiektem a innym elementem (w naszym przypadku łańcuch znaków). Użyliśmy metody get() do pobrania elementu powiązanego z obiektem. Ciekawy aspekt WeakMaps to fakt, że posiada słabe odniesienie do klucza wewnątrz mapy. Słabe odniesienie oznacza, że jeśli obiekt zostanie zniszczony, garbage collector usunie cały wpis z WeakMap, uwalniając w ten sposób pamięć.

var TheatreSeats = (function() {
  var priv = new WeakMap();
  var _ = function(instance) {
    return priv.get(instance);
  };

  return (function() {
      function TheatreSeatsConstructor() {
        var privateMembers = {
          seats: []
        };
        priv.set(this, privateMembers);
        this.maxSize = 10;
      }
      TheatreSeatsConstructor.prototype.placePerson = function(person) {
        _(this).seats.push(person);
      };
      TheatreSeatsConstructor.prototype.countOccupiedSeats = function() {
        return _(this).seats.length;
      };
      TheatreSeatsConstructor.prototype.isSoldOut = function() {
        return _(this).seats.length >= this.maxSize;
      };
      TheatreSeatsConstructor.prototype.countFreeSeats = function() {
        return this.maxSize - _(this).seats.length;
      };
      return TheatreSeatsConstructor;
    }());
})()

Używam WeakMap do buforowania bezproblemowej memoizacji funkcji, które przyjmują jako swój parametr obiekty niezmienne.

Memoizacja jest wymyślnym sposobem na powiedzenie "po obliczeniu wartości, buforuj ją, więc nie musisz jej ponownie obliczać".

Oto przykład:

// using immutable.js from here https://facebook.github.io/immutable-js/

const memo = new WeakMap();

let myObj = Immutable.Map({a: 5, b: 6});

function someLongComputeFunction (someImmutableObj) {
  // if we saved the value, then return it
  if (memo.has(someImmutableObj)) {
    console.log('used memo!');
    return memo.get(someImmutableObj);
  }
  
  // else compute, set, and return
  const computedValue = someImmutableObj.get('a') + someImmutableObj.get('b');
  memo.set(someImmutableObj, computedValue);
  console.log('computed value');
  return computedValue;
}


someLongComputeFunction(myObj);
someLongComputeFunction(myObj);
someLongComputeFunction(myObj);

// reassign
myObj = Immutable.Map({a: 7, b: 8});

someLongComputeFunction(myObj);

<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.1/immutable.min.js"></script>

Kilka rzeczy do zapamiętania:

• niezmienny.obiekty js zwracają nowe obiekty (z nowym wskaźnikiem) podczas ich modyfikowania, więc używanie ich jako kluczy w Weakmapie jest gwarancją ta sama obliczona wartość.
• WeakMap jest świetny do notatek, ponieważ gdy obiekt (używany jako klucz) pobiera śmieci, tak samo jak obliczona wartość na Weakmapie.

Słabe mapy mogą być używane do przechowywania metadanych o elementach DOM bez zakłócania zbierania śmieci lub wkurzania współpracowników na Twój kod. Można na przykład użyć ich do numerycznego indeksowania wszystkich elementów na stronie internetowej.

Bez słabych i słabych stron:

var elements = document.getElementsByTagName('*'),
  i = -1, len = elements.length;

while (++i !== len) {
  // Production code written this poorly makes me want to cry:
  elements[i].lookupindex = i;
  elements[i].elementref = [];
  elements[i].elementref.push( elements[Math.pow(i, 2) % len] );
}

// Then, you can access the lookupindex's
// For those of you new to javascirpt, I hope the comments below help explain 
// how the ternary operator (?:) works like an inline if-statement
document.write(document.body.lookupindex + '<br />' + (
    (document.body.elementref.indexOf(document.currentScript) !== -1)
    ? // if(document.body.elementref.indexOf(document.currentScript) !== -1){
    "true"
    : // } else {
    "false"
  )   // }
);

Używanie WeakMap i WeakSets:

var DOMref = new WeakMap(),
  __DOMref_value = Array,
  __DOMref_lookupindex = 0,
  __DOMref_otherelement = 1,
  elements = document.getElementsByTagName('*'),
  i = -1, len = elements.length, cur;

while (++i !== len) {
  // Production code written this greatly makes me want to :
  cur = DOMref.get(elements[i]);
  if (cur === undefined)
    DOMref.set(elements[i], cur = new __DOMref_value)

  cur[__DOMref_lookupindex] = i;
  cur[__DOMref_otherelement] = new WeakSet();
  cur[__DOMref_otherelement].add( elements[Math.pow(i, 2) % len] );
}

// Then, you can access the lookupindex's
cur = DOMref.get(document.body)
document.write(cur[__DOMref_lookupindex] + '<br />' + (
    cur[__DOMref_otherelement].has(document.currentScript)
    ? // if(cur[__DOMref_otherelement].has(document.currentScript)){
    "true"
    : // } else {
    "false"
  )   // }
);

Różnica

Różnica może wyglądać na znikomą, pomijając fakt, że wersja weakmap jest dłuższa, jednak istnieje duża różnica między dwoma fragmentami kodu pokazanymi powyżej. W pierwszym fragmencie kodu, bez słabych map, fragment kodu przechowuje odniesienia pomiędzy elementami DOM. Zapobiega to zbieraniu śmieci z elementów DOM. Math.pow(i, 2) % len] może wydawać się dziwakiem, którego nikt by nie użył, ale pomyśl jeszcze raz: wiele kodu produkcyjnego ma odwołania do DOM, które odbijają się po całym dokumencie. Teraz, dla drugiego kawałka kodu, ponieważ wszystkie odniesienia do elementów są słabe, gdy usuniesz węzeł, przeglądarka jest w stanie określić, że węzeł nie jest używany (nie można do niego dotrzeć za pomocą kodu), a tym samym usunąć go z pamięci. Powodem, dla którego powinieneś martwić się o zużycie pamięci i kotwice pamięci (takie jak pierwszy fragment kodu, w którym nieużywane elementy są przechowywane w pamięci), jest to, że większe zużycie pamięci oznacza więcej prób GC przeglądarki (aby spróbować zwolnić pamięć, aby uniknąć awarii przeglądarki) oznacza wolniejsze przeglądanie, a czasami przeglądarka crash.

Jeśli chodzi o polyfill do tych, polecam własną bibliotekę (znajdującą się tutaj @ github ). Jest to bardzo lekka biblioteka, która po prostu wypełni ją bez zbyt skomplikowanych frameworków, które można znaleźć w innych polyfillach.