Is it possible to create a “weak reference” in javascript?

Question

Is there any way in javascript to create a \"weak reference\" to another object? Here is the wiki page describing what a weak reference is. Here is another article that desc

Answer 1

When running JS on NodeJS, you may consider https://github.com/TooTallNate/node-weak.

Answer 2

Update: September 2019

It is not possible to use weak references yet, but most likely soon it will be possible, as WeakRefs in JavaScript are Work In Progress. Details below.

Proposal

Proposal in now in Stage 3 which means that it has complete specification and that further refinement will require feedback from implementations and users.

The WeakRef proposal encompasses two major new pieces of functionality:

• Creating weak references to objects with the WeakRef class
• Running user-defined finalizers after objects are garbage-collected, with the FinalizationGroup class

Use cases

A primary use for weak references is to implement caches or mappings holding large objects, where it’s desired that a large object is not kept alive solely because it appears in a cache or mapping.

Finalization is the execution of code to clean up after an object that has become unreachable to program execution. User-defined finalizers enable several new use cases, and can help prevent memory leaks when managing resources that the garbage collector doesn't know about.

Source and further reading

https://github.com/tc39/proposal-weakrefs
https://v8.dev/features/weak-references

Answer 3

Using a caching mechanism to emulate a weak reference, as JL235 suggested above, is reasonable. If weak references would exist natively, you would observe a behavior like this:

this.val = {};
this.ref = new WeakReference(this.val);
...
this.ref.get(); // always returns val
...
this.val = null; // no more references
...
this.ref.get(); // may still return val, depending on already gc'd or not

Whereas with a cache you would observe:

this.val = {};
this.key = cache.put(this.val);
...
cache.get(this.key); // returns val, until evicted by other cache puts
...
this.val = null; // no more references
...
cache.get(this.key); // returns val, until evicted by other cache puts

As a holder of a reference, you should not make any assumptions about when it refers to a value, this is no different using a cache