Multiple Approaches for Implementing Unique Hash Keys for Objects in JavaScript

In-depth Analysis of JavaScript Object Key Mechanism

In JavaScript, object property keys are essentially converted to string type. This means when non-string values are used as keys, the JavaScript engine implicitly calls the value's toString() method for conversion. For primitive data types like strings and numbers, this conversion is intuitive and predictable. However, for regular objects, the default toString() method returns a fixed string like "[object Object]", causing all object instances to point to the same property when used as keys.

Array Index-Based Solution

An effective approach involves maintaining a global object reference array and generating unique string identifiers through array indices. The specific implementation is as follows:

var ObjectReference = [];

function addToSet(obj, set) {
    var index = ObjectReference.indexOf(obj);
    if (index === -1) {
        index = ObjectReference.push(obj) - 1;
    }
    set['ObjectReference.' + index] = true;
}

// Usage example
var mySet = {};
var obj1 = {name: "test1"};
var obj2 = {name: "test2"};

addToSet(obj1, mySet);
addToSet(obj2, mySet);

console.log(mySet); // Output: {ObjectReference.0: true, ObjectReference.1: true}

The advantage of this method lies in guaranteeing uniqueness for each object while maintaining relative simplicity. However, attention must be paid to array maintenance costs and memory management issues.

Custom toString Method Implementation

Another common approach involves defining custom toString methods for objects to generate unique string identifiers:

(function() {
    var id = 0;
    
    function UniqueObject() {
        this.objectId = '<#UniqueObject:' + (id++) + '>';
        this.toString = function() {
            return this.objectId;
        };
    }
    
    // Usage example
    var obj1 = new UniqueObject();
    var obj2 = new UniqueObject();
    var set = {};
    
    set[obj1] = true;
    set[obj2] = true;
    
    console.log(set); // Each object has unique keys
})();

This method is more object-oriented but requires ensuring that generated identifiers don't conflict with existing string keys.

ECMAScript 6 WeakMap Solution

With the widespread adoption of ECMAScript 6, WeakMap provides a more elegant solution:

// Create WeakMap instance
var objectMap = new WeakMap();

// Store object-associated data
var obj1 = {};
var obj2 = function() {};

objectMap.set(obj1, {data: "value1"});
objectMap.set(obj2, {data: "value2"});

// Retrieve data
console.log(objectMap.get(obj1)); // Output: {data: "value1"}
console.log(objectMap.get(obj2)); // Output: {data: "value2"}

// Check existence
console.log(objectMap.has(obj1)); // Output: true

The advantage of WeakMap is that its keys can be any objects and it doesn't prevent garbage collection, making it particularly suitable for scenarios requiring object unique identification.

Hash Function Implementation

For scenarios requiring traditional hash codes, a hash function similar to Java's can be implemented:

function hashCode(str) {
    var hash = 0;
    for (var i = 0; i < str.length; i++) {
        var code = str.charCodeAt(i);
        hash = ((hash << 5) - hash) + code;
        hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
}

// Generate hash using object string representation
function objectHashCode(obj) {
    return hashCode(JSON.stringify(obj));
}

Prototype Extension Method

By extending the Function prototype, hash code generation capability can be added to all objects:

Function.prototype.getHashCode = (function(id) {
    return function() {
        if (!this.hashCode) {
            this.hashCode = '<hash|#' + (id++) + '>';
        }
        return this.hashCode;
    };
}(0));

// Usage example
var obj = {};
console.log(obj.getHashCode()); // Output unique hash identifier

Solution Comparison and Selection Recommendations

When choosing specific implementation solutions, the following factors should be considered:

• Compatibility Requirements: WeakMap requires ES6 support, traditional solutions have better compatibility
• Performance Needs: Array index solution may be slower with large numbers of objects
• Memory Management: WeakMap automatically handles garbage collection, other solutions require manual management
• Development Complexity: Custom toString method is simple to implement but requires attention to identifier conflicts

For modern JavaScript applications, WeakMap solution is recommended as the first choice; for scenarios requiring backward compatibility, array index-based or custom toString methods are good alternatives.