In my recent blog post titled Exploring ES 6: A Brief Overview of Weak Maps, I delved into how jQuery effectively prevents memory leaks when using the data() method. The key lies in the creation of an expando property named jQuery.expando. This property stores data in an internal cache array, linking it to the element through the expando property with a corresponding index value.
element[jQuery.expando] = elementId;
To avoid circular references, it is crucial not to directly attach objects as expandos to elements. Failure to do so may prevent the garbage collection process even if the element is removed from the DOM. While mitigating circular references helps plug some leaks, residual data can still linger in the array after removal and garbage collection. Hence, jQuery clears this array upon page unload and removes data when elements are deleted from the DOM using methods like remove(), allowing data persistence for detach().
The absence of a weak map equivalent in older JavaScript versions such as ES 3 necessitates these measures since available implementations like WeakMap in Firefox 6 onwards remain tentative for production usage due to incomplete specifications.
Moreover, certain elements like <object> and <embed> pose restrictions on attaching expando properties, as noted within the jQuery source code. Attempting to utilize data on these elements proves futile.
Circular reference memory leaks commonly afflict reference counted implementations where two objects mutually hold direct references. For instance, DOMObject maintains a link to JSObject and vice versa, resulting in perpetual reference counts of 1 that evade garbage collection if no other references exist. While modern browsers are adept at identifying and breaking such patterns on page unload, obsolete ones like IE6 lag behind in resolving these issues.
Persistence of circular references poses challenges despite advancements, with retroactive resolutions introduced in newer browsers like IE 8 reducing but not entirely eradicating potential leaks. Although workarounds like jQuery.cache pattern help mitigate risks by decoupling object references, remnants of circular dependencies persist. Absence of mechanisms like WeakMap() compels reliance on methodologies like jQuery's data pattern to manage memory efficiently albeit risking orphaned objects as a trade-off against more severe memory leaks.