Shared String Pool in JavaScript

String manipulation is a common task in JavaScript, and repeated creation of identical strings can lead to performance inefficiencies, especially in large applications. This challenge asks you to implement a shared string pool that reuses existing strings instead of creating new ones, optimizing memory usage and potentially improving performance. This is particularly useful when dealing with frequently used, constant strings.

Problem Description

You are tasked with creating a StringPool class in JavaScript. This class should manage a pool of strings and provide a method to retrieve a string. If the requested string already exists in the pool, the existing string object should be returned. If the string doesn't exist, a new string object should be created, added to the pool, and then returned. The pool should be case-sensitive.

Key Requirements:

• StringPool Class: Define a class named StringPool.
• getString(str) Method: This method takes a string str as input.
• String Reuse: If str already exists in the pool, return the existing string object.
• String Creation: If str does not exist, create a new string object, add it to the pool, and return it.
• Case Sensitivity: The pool should be case-sensitive. "hello" and "Hello" should be treated as distinct strings.
• Immutability: The pool should not modify the original string passed to getString. It should return a reference to the string object stored in the pool.

Expected Behavior:

The StringPool should efficiently manage string objects, minimizing memory usage by reusing identical strings. The getString method should always return a string object, either existing or newly created.

Edge Cases to Consider:

• Empty strings: The pool should handle empty strings correctly.
• Null or undefined input: The getString method should handle null or undefined input gracefully (e.g., by returning an empty string or throwing an error – specify your choice in the Notes section).
• Large number of strings: The pool should be able to handle a large number of strings without significant performance degradation.

Examples

Example 1:

Input:
const pool = new StringPool();
pool.getString("hello");
pool.getString("hello");
pool.getString("world");
pool.getString("world");

Output:
// The first two calls to pool.getString("hello") should return the same string object.
// The next two calls to pool.getString("world") should return the same string object.

Explanation: The first getString("hello") creates a new string "hello" and adds it to the pool. The second getString("hello") retrieves the existing "hello" string from the pool. The same logic applies to "world".

Example 2:

Input:
const pool = new StringPool();
pool.getString("Hello");
pool.getString("hello");

Output:
// pool.getString("Hello") and pool.getString("hello") should return different string objects.

Explanation: Because the pool is case-sensitive, "Hello" and "hello" are treated as distinct strings, and each call creates a new string object.

Example 3: (Edge Case)

Input:
const pool = new StringPool();
pool.getString("");
pool.getString("");

Output:
// Both calls to pool.getString("") should return the same string object (an empty string).

Explanation: The pool correctly handles empty strings, reusing the same empty string object.

Constraints

• The pool should be implemented using a JavaScript object (or Map) for efficient string lookup.
• The getString method should have an average time complexity of O(1).
• The input string str to getString can be any string, including empty strings, strings with spaces, and strings with special characters.
• The maximum length of the input string str is 255 characters.

Notes

• You are free to choose how to handle null or undefined input to the getString method. Document your choice in a comment within your code. Returning an empty string is a reasonable default.
• Consider the trade-offs between memory usage and performance when designing your solution.
• Focus on creating a clean, well-documented, and efficient implementation.
• No external libraries are allowed.
• The primary goal is to demonstrate understanding of string immutability and efficient data structure usage for string pooling.