Benchmark: memoizeOne - complex types

HTML Preparation code:

<script src="https://pkgzip.com/bundle.js?packages=memoize-one@1.0.2,fast-memoize@2.2.0,underscore@1.8.3,lodash@4.17.4,moize@2.2.1,memoizejs@0.1.1,moize@2.2.1,reselect@2.5.4"></script>

Script Preparation code:

var fn = function() {
  for(var i = 0; i < 2000; i++) {
    void(undefined); 
  }
}

var modules = window.pkgzip;

var memoizeOneFn = modules.memoizeOne.default(fn);
var fastMemoizeFn = modules.fastMemoize(fn);
var underscoreFn = modules.underscore.memoize(fn);
var lodashFn = modules.lodash.memoize(fn);
var memoizejsFn = modules.memoizejs(fn);
var reselectFn = modules.reselect.defaultMemoize(fn);
var moizeFn = modules.moize(fn);

var arg = {foo: 'bar'}

Tests:

baseline
fn(arg);
memoizeOne
memoizeOneFn(arg);
fastMemoize
fastMemoizeFn(arg);
lodash
lodashFn(arg);
underscore
underscoreFn(arg);
memoizejs
memoizejsFn(arg);
reselect
reselectFn(arg);
moize
moizeFn(arg)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
baseline
memoizeOne
fastMemoize
lodash
underscore
memoizejs
reselect
moize

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36

Browser/OS: Chrome 56 on Mac OS X 10.12.3

View result in a separate tab

Test name	Executions per second
baseline	2838.3 Ops/sec
memoizeOne	3810030.2 Ops/sec
fastMemoize	823358.8 Ops/sec
lodash	2932248.2 Ops/sec
underscore	2801215.8 Ops/sec
memoizejs	834046.5 Ops/sec
reselect	3507489.0 Ops/sec
moize	4666812.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of memoization and explore what's being tested in this benchmark.

**Memoization: A brief introduction**

Memoization is an optimization technique that stores the results of expensive function calls so that they can be reused instead of recalculated. This technique can significantly improve performance in situations where a function is called with the same inputs multiple times.

**The benchmark's purpose**

In this benchmark, we're comparing the performance of different memoization libraries: `memoizeOne`, `fastMemoize`, `lodash.memoize`, and others. The goal is to determine which library provides the best performance for a specific use case (in this case, a simple function with complex types).

**Options compared**

The following options are being compared:

1. `memoizeOne`: A custom implementation of memoization.
2. `fastMemoize`: A fast memoization library that likely uses various optimization techniques to improve performance.
3. `lodash.memoize` and `underscore.memoize`: Memoization functions provided by the popular `lodash` and `underscore` libraries, respectively.

**Pros and Cons**

Here's a brief summary of each option:

1. **memoizeOne**:
	* Pros: Custom implementation allows for fine-grained control over memoization logic.
	* Cons: May not be optimized for performance like other libraries.
2. **fastMemoize**:
	* Pros: Optimized for performance, likely using various techniques to improve caching and reuse.
	* Cons: May have a steeper learning curve due to its custom implementation.
3. **lodash.memoize** and **underscore.memoize**:
	* Pros: Well-established libraries with optimized implementations.
	* Cons: May require additional dependencies or import statements.

**Other considerations**

The benchmark also includes a "baseline" test, which calls the original function without memoization. This helps establish a lower bound for performance comparison.

**Special JS feature or syntax**

There's no special JavaScript feature or syntax being tested in this benchmark. The focus is on comparing different memoization libraries and their implementations.

**Library descriptions**

Here are brief descriptions of each library mentioned:

1. **memoizeOne**: A custom implementation of memoization, likely written by the authors of the benchmark.
2. **fastMemoize**: A fast memoization library that uses various optimization techniques to improve performance. Its exact implementation is not publicly available, but it's designed to be efficient and scalable.
3. **lodash.memoize** and **underscore.memoize**: Memoization functions provided by popular JavaScript libraries `lodash` and `underscore`, respectively.

I hope this helps you understand the benchmark's purpose and comparisons!

Related benchmarks:

memoizeOne - complex types (version: 1)

Comparing the performance of memoizeOne to other memoization libraries

Comparing performance of: baseline vs memoizeOne vs fastMemoize vs lodash vs underscore vs memoizejs vs reselect vs moize

Created: 7 years ago by: Registered User

Jump to the latest result

baseline

memoizeOne

fastMemoize

lodash

underscore

memoizejs

reselect

moize

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):