JavaScript 弱集合：内存高效的存储与高级用例

            
let elementData = new WeakMap();

let myElement = document.createElement('div');

// Associate data with the element
elementData.set(myElement, { id: 123, label: 'My Element' });

// Retrieve data associated with the element
console.log(elementData.get(myElement)); // Output: { id: 123, label: 'My Element' }

// When myElement is no longer referenced elsewhere and garbage collected,
// its entry in elementData will also be removed automatically.
myElement = null; // Remove the strong reference

            

              
                Copy
              
            
          

            
let processedElements = new WeakSet();

let element1 = document.createElement('div');
let element2 = document.createElement('span');

// Add elements to the WeakSet after processing
processedElements.add(element1);
processedElements.add(element2);

// Check if an element has been processed
console.log(processedElements.has(element1)); // Output: true
console.log(processedElements.has(document.createElement('p'))); // Output: false

// When element1 and element2 are no longer referenced elsewhere and garbage collected,
// they will be automatically removed from processedElements.
element1 = null;
element2 = null;

            

              
                Copy
              
            
          

            
let cache = new WeakMap();

function expensiveCalculation(obj) {
 console.log('Performing expensive calculation for:', obj);
 // Simulate an expensive calculation
 return obj.id * 2;
}

function getCachedResult(obj) {
 if (cache.has(obj)) {
 console.log('Retrieving from cache');
 return cache.get(obj);
 } else {
 let result = expensiveCalculation(obj);
 cache.set(obj, result);
 return result;
 }
}

let myObject = { id: 5 };

console.log(getCachedResult(myObject)); // Performs calculation and caches the result
console.log(getCachedResult(myObject)); // Retrieves from cache

myObject = null; // Object is eligible for garbage collection
// Eventually, the entry in the cache will be removed.

            

              
                Copy
              
            
          

            
let privateData = new WeakMap();

class MyClass {
 constructor(secret) {
 privateData.set(this, { secret });
 }

 getSecret() {
 return privateData.get(this).secret;
 }
}

let instance = new MyClass('MySecret');
console.log(instance.getSecret()); // Output: MySecret

// Attempting to access privateData directly will not work.
// console.log(privateData.get(instance)); // undefined

instance = null;
// When instance is garbage collected, the associated private data will also be removed.

            

              
                Copy
              
            
          

            
let elementListeners = new WeakMap();

function addClickListener(element, callback) {
 if (!elementListeners.has(element)) {
 elementListeners.set(element, []);
 }

 let listeners = elementListeners.get(element);
 listeners.push(callback);

 element.addEventListener('click', callback);
}

function removeClickListener(element, callback) {
 if (elementListeners.has(element)) {
 let listeners = elementListeners.get(element);
 let index = listeners.indexOf(callback);
 if (index > -1) {
 listeners.splice(index, 1);
 element.removeEventListener('click', callback);
 }
 }
}

let myButton = document.createElement('button');
myButton.textContent = 'Click Me';
document.body.appendChild(myButton);

let clickHandler = () => {
 console.log('Button Clicked!');
};

addClickListener(myButton, clickHandler);

// When myButton is removed from the DOM and garbage collected,
// the associated event listener will also be removed.
myButton.remove();
myButton = null;

            

              
                Copy
              
            
          

            
let validatedObjects = new WeakSet();

function validateObject(obj) {
 // Perform validation logic
 console.log('Validating object:', obj);
 let isValid = obj.id > 0;

 if (isValid) {
 validatedObjects.add(obj);
 }

 return isValid;
}

let obj1 = { id: 5 };
let obj2 = { id: -2 };

validateObject(obj1);
validateObject(obj2);

console.log(validatedObjects.has(obj1)); // Output: true
console.log(validatedObjects.has(obj2)); // Output: false

obj1 = null;
obj2 = null;
// When obj1 and obj2 are garbage collected, they will also be removed from validatedObjects.

            

              
                Copy