# Question 33

### Question

How would you create a custom symbol registry to prevent collision of Symbol values?

### Answer

While the `Symbol()` function generates unique symbols in most cases, creating a custom symbol registry can be beneficial for specific scenarios where you need finer control and predictability over symbol assignments.

Here's how you could implement a basic custom symbol registry:

```javascript
class SymbolRegistry {
  constructor() {
    this.symbols = {}; // Map to store registered symbols
  }

  register(name) {
    if (!this.hasSymbol(name)) {
      const symbol = Symbol(name); 
      this.symbols[name] = symbol;
      return symbol;
    } else {
      console.warn(`Symbol '${name}' already exists in the registry`);
      return this.symbols[name];
    }
  }

  hasSymbol(name) {
    return !!this.symbols[name];
  }

  getSymbol(name) {
    return this.symbols[name];
  }
}

// Usage Example:
const registry = new SymbolRegistry();

const mySymbol1 = registry.register('data');
const mySymbol2 = registry.register('view'); 

console.log(mySymbol1); // Output unique symbol for 'data'
console.log(registry.getSymbol('data')); // Accessing the registered symbol


```

**Explanation:**

1. **SymbolRegistry Class:** We create a class to manage our symbols. It has a `symbols` map to store registered symbols using names as keys.
2. **`register(name)` Method:**
   * Checks if a symbol with the given `name` already exists in the registry.
   * If not, it generates a new symbol using `Symbol(name)` and stores it in the `symbols` map, returning the newly created symbol.
3. **`hasSymbol(name)` Method:**
   * Checks if a symbol with the given `name` is present in the registry.
4. **`getSymbol(name)` Method:**
   * Returns the previously registered symbol associated with the given `name`.

**Benefits of Using a Symbol Registry:**

* **Controlled Namespace:** Ensures that symbols used within your application are unique and avoid collisions, even across different modules or components.
* **Readability and Maintainability:** Makes it easier to understand which symbols represent specific concepts in your code.
* **Testability:** You can easily mock or stub symbol values during testing.