Benchmark: Ways to cache Intl.NumberFormat

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js'></script>

Script Preparation code:

const formatOptions = {
  minimumFractionDigits: 0,
  maximumFractionDigits: 0,
  useGrouping: false,
  style: 'percent',
};

const staticInstanceDe = new Intl.NumberFormat("de", formatOptions);
const staticInstanceFr = new Intl.NumberFormat("fr", formatOptions);

const lodashCache = _.memoize(
    (locale, options) => new Intl.NumberFormat(locale, options),
    (locale, options) => `${locale}-${JSON.stringify(options)}`,
);

const mapCache = new Map();
const getMapCacheInstance = (locale, options) => {
  let lang;
  if (!mapCache.has(locale)) {
    lang = new Map();
    mapCache.set(locale, lang);
  } else {
    lang = mapCache.get(locale);
  }
  if (!lang.has(options)) {
    const newInstance = new Intl.NumberFormat(locale, options);
    lang.set(options, newInstance);
    return newInstance;
  }
  return lang.get(options);
}

const objCache = {};
const getObjCacheInstance = (locale, options) => {
  let lang = objCache[locale];
  if (!lang) {
    lang = {};
    objCache[locale] = lang;
  }
  if (!lang[options]) {
    const newInstance = new Intl.NumberFormat(locale, options);
    lang[options] = newInstance;
    return newInstance;
  }
  return lang[options];
}

Tests:

Always new instance
new Intl.NumberFormat("de", formatOptions).format(0.123) new Intl.NumberFormat("fr", formatOptions).format(0.123)
static global instance
staticInstanceDe.format(0.123) staticInstanceFr.format(0.123)
Lodash cache
lodashCache("de", formatOptions).format(0.123) lodashCache("fr", formatOptions).format(0.123)
Custom cache with maps
getMapCacheInstance("de", formatOptions).format(0.123) getMapCacheInstance("fr", formatOptions).format(0.123)
Custom cache with objects
getObjCacheInstance("de", formatOptions).format(0.123) getObjCacheInstance("fr", formatOptions).format(0.123)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Always new instance
static global instance
Lodash cache
Custom cache with maps
Custom cache with objects

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.0.0

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Always new instance	22599.6 Ops/sec
static global instance	853766.8 Ops/sec
Lodash cache	505681.2 Ops/sec
Custom cache with maps	811703.8 Ops/sec
Custom cache with objects	707904.9 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark titled "Ways to cache Intl.NumberFormat" evaluates different strategies for caching instances of `Intl.NumberFormat`, which is a built-in JavaScript object used for formatting numbers according to specific locales (e.g., German, French) and options (like decimal places or percentage formatting). The comparison focuses on performance, specifically how quickly each method allows numbers to be formatted based on these cached instances.

### Options Compared

1. **Always new instance**:
   - **Benchmark Definition**: Creates a new `Intl.NumberFormat` instance for each formatting request.
   - **Execution Logic**: `new Intl.NumberFormat("de", formatOptions).format(0.123)` followed by `new Intl.NumberFormat("fr", formatOptions).format(0.123)`.
   - **Pros**: Ensures that each instance is fresh, thus avoiding unexpected side effects from state. 
   - **Cons**: Poor performance due to the overhead of creating instances repeatedly, resulting in many unnecessary allocations.

2. **Static global instance**:
   - **Benchmark Definition**: Uses predefined static instances of `Intl.NumberFormat` for German and French.
   - **Execution Logic**: Calls methods on `staticInstanceDe.format(0.123)` and `staticInstanceFr.format(0.123)`.
   - **Pros**: Significant performance improvement as instances are created only once and reused.
   - **Cons**: Less flexible. If different options were needed, additional instances would have to be created.

3. **Lodash cache**:
   - **Benchmark Definition**: Utilizes Lodash’s `memoize` function to cache instances based on locale and options.
   - **Execution Logic**: `lodashCache("de", formatOptions).format(0.123)` and `lodashCache("fr", formatOptions).format(0.123)`.
   - **Pros**: Allows for flexible caching; instances are reused based on a calculated key.
   - **Cons**: More complex and potentially slower due to the overhead of managing the cache. Depending on usage, might consume more memory if many unique combinations are cached.

4. **Custom cache with maps**:
   - **Benchmark Definition**: Caches in a Map using a nested structure for locales and options.
   - **Execution Logic**: Calls `getMapCacheInstance("de", formatOptions).format(0.123)` and `getMapCacheInstance("fr", formatOptions).format(0.123)`.
   - **Pros**: Fast look-up and good memory management; only holds onto relevant instances and can be cleared easily.
   - **Cons**: Slightly more complicated than just static instances and may require more overhead than simple look-ups depending on implementation.

5. **Custom cache with objects**:
   - **Benchmark Definition**: Similar approach as the Map cache, but uses plain objects to achieve the same goals.
   - **Execution Logic**: Implements `getObjCacheInstance("de", formatOptions).format(0.123)` and `getObjCacheInstance("fr", formatOptions).format(0.123)`.
   - **Pros**: Simplicity of plain objects for caching; often has acceptable performance.
   - **Cons**: Objects need proper management for keys since they can’t be deleted from the cache as elegantly as Maps, potentially leading to memory issues.

### Other Considerations

- **Performance Measurements**: The benchmark provides a measurable way to compare the number of executions per second for each method. For instance, static instances gave the best performance, while creating new instances showed the slowest performance by far.
- **Memory Usage**: While performance is crucial, memory consumption is another consideration—using caches can lead to increased memory requirements if not managed correctly.
- **Scalability**: Depending on how many locales and formatting options are used, caching can offer performance benefits, but can also become a bottleneck if too many unique instances are cached unnecessarily.

### Alternatives

Though the approaches listed above are effective, here are some alternatives that can be considered:

- **Using functions or classes tailored to common formatting needs**: Instead of endlessly caching variations, you could create specific functions that cover the most commonly needed cases.
- **Leveraging application-level caching mechanisms**: In a more extensive application, consider using a full caching library or service, especially if the application's scale might demand a different cache invalidation logic and persistence.
- **Exploring performance optimization tools**: Instead of optimizing just the caching, using profiler tools to analyze bottlenecks or leveraging asynchronous patterns for operations that can be done in parallel can yield better performance as well.

Related benchmarks:

Ways to cache Intl.NumberFormat (version: 2)

Try to test different ways of keeping Intl.NumberFormat instances for better performance.

Comparing performance of: Always new instance vs static global instance vs Lodash cache vs Custom cache with maps vs Custom cache with objects

Created: 2 months ago by: Registered User

Jump to the latest result

Always new instance

static global instance

Lodash cache

Custom cache with maps

Custom cache with objects

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):