Is it possible to implement a two-way weak map in JavaScript?

Question

Is it possible to make something like a WeakMap that is two way (get a value by its key, or get a key by its value)?

The usage would look like this (in TypeScript syntax to better illustrate):

class TwoWayWeakMap {
  // What goes here?
}

class SomeClass {}

const map = new TwoWayWeakMap<SomeClass, number>()

const o = new SomeClass

map.set(o, 42)

console.log(map.get(o)) // logs "42"
console.log(map.keyFrom(42)) // logs "SomeClass {}" (the `o` object)

At any point later, if o is no longer referenced except inside the TwoWayWeakMap, then the SomeClass object that o was pointing to could be collected.

NOTE! The second argument to map.set(k, v) must be allowed to be anything, not just objects. v can be a number, for example.

Answer 1

Here's how to do it one way:

<script type=module>
    let tick = 0
  
    const loop = setInterval(() => {
        const obj = window.map.keyFrom(42)
    
        console.log(`o still exists? (${tick++})`, !!obj)
    
        if (!obj) {
            clearInterval(loop)
            console.log('o was collected!')
        }
    }, 300)
</script>

<script type=module>
    class TwoWayWeakMap /*<K extends object = object, V = unknown>*/
      extends WeakMap /*<K, V>*/ {
    
        #refs /*: Set<WeakRef>*/ = new Set();
    
        constructor() {
            super();
            setInterval(() => this.maybeCleanup(), 1000);
        }
    
        set(k /*: K*/ , v /*: V*/ ) /*: void*/ {
            super.set(k, v);
            this.#refs.add(new WeakRef(k));
        }
    
        keyFrom(v /*: V*/ ) /*: K | undefined*/ {
            for (const ref of this.#refs) {
                const o = ref.deref();
                if (!o) {
                    this.#refs.delete(ref);
                    continue;
                }
                if (this.get(o) === v) return o;
            }
        }
    
        maybeCleanup() {
            for (const ref of this.#refs) {
                const o = ref.deref();
                if (!o) this.#refs.delete(ref);
            }
        }
    }
  
    class SomeClass {}

    function main() {
        const map = (window.map = new TwoWayWeakMap /*<SomeClass, number>*/());
        const o = new SomeClass();
        map.set(o, 42);
        console.log(map.get(o)); // logs "42"
        console.log('Get object from key:', !!map.keyFrom(42)); // logs "true"
    }
  
    main();
  
    // At this point there is no reference to `o`, except by
    // WeakRef and WeakMap, so `o` should be collectable.
</script>

Kaiido provided another way to do it, using a second map to eliminate the need for iteration:

class TwoWayWeakMap extends WeakMap {
  #reverseMap;
  constructor( iterable ) {
    super(iterable);
    this.#reverseMap = new Map();
    if (iterable) {
      for (const [k,v] of iterable ) {
        this.set(k,v);
      }
    }
  }
  set(k,v) {
    super.set(k,v);
    this.#reverseMap.set(v, new WeakRef(k));
  }
  keyFrom(v) {
    const k = this.#reverseMap.get(v)?.deref();
    if (!k) { // suboptimal clean value at getting...
      this.#reverseMap.delete(v);
    };
    return k;
  }
}

class SomeClass {}

const map = new TwoWayWeakMap();
{
  const o = new SomeClass();

  map.set(o, 42)

  console.log(map.get(o)) // logs "42"
  console.log(map.keyFrom(42) === o) // logs "SomeClass {}" (the `o` object)
}
// check it gets collected, eventually
// convert to Boolean to avoid the console keeping an hard reference
setInterval(() => console.log(!!map.keyFrom(42)), 1000 );

Answer 2

FinalizationRegistry makes it more perfect!

class TwoWayWeakMap<K extends object, V extends any = any> {
  _map = new WeakMap<K, V>()
  _keyMap = new Map<V, WeakRef<K>>()
  _registry: FinalizationRegistry<V>

  constructor() {
    this._registry = new FinalizationRegistry<V>((key) => {
      this._keyMap.delete(key)
    })
  }

  set(key: K, value: V) {
    this._map.set(key, value)
    this._keyMap.set(value, new WeakRef(key))
    this._registry.register(key, value)
  }

  get(key: K): V | undefined {
    return this._map.get(key)
  }

  has(key: K): boolean {
    return this._map.has(key)
  }

  keyFrom(value: V): K | undefined {
    const ref = this._keyMap.get(value)
    return ref?.deref()
  }
}

async function main() {
  const map = new TwoWayWeakMap()
  let data = { hello: "world!" } as any
  map.set(data, "something!")

  console.log('---before---')
  console.log(map.keyFrom("something!"))

  data = null
  await new Promise((resolve) => setTimeout(resolve, 0))
  global.gc() // call gc manually
  await new Promise((resolve) => setTimeout(resolve, 0))

  console.log('---after--')
  console.log(map.keyFrom("something!"))
}

main()

It must be run with the --expose-gc option in the node.js environment.

Answer 3

Doesn't seem like it ought to be any more complex than

class TwoWayWeakMap extends WeakMap {
  
  constructor(iterable) {
    super(iterable);
    if (iterable) {
      for (const [k,v] of iterable ) {
        this.set(k,v);
      }
    }
  }

  set(k,v) {
    super.set(k,v);
    super.set(v,k);
  }

}

Caveats

• There is an implicit assumption here that the set union of the keys and values itself forms a set (which is to that that the set of keys is itself unique, the set of values is itself unique, and there is commonality between the two).

• If either k or v is an object, since the methods of Set, Map, WeakSet, and WeakMap use reference equality, only that exact same object will match. Anything else, even if it is an exact duplicate will not match.