Memor: More memoization.
Memoization, but good. Works with functions of an arbitrary and/or variable number of arguments. For arrays, regexes, dates, buffers, and POJOs, caching is done according to the value (and not the identity) of the objects. Order of keys in POJOs does not matter. For other non-primitive values, memoization still works, but the caching is done by object identity.
- Node.js 6+
const memoizedFunction =
originalFunction can accept any number or a variable number of arguments. Re-memoizing the same function (i.e., calling
memoize(originalFunction) elsewhere later) will share the cached values.
Keying of primitives, regexes, dates, and buffers works according to their values. Any additional custom properties added to the objects will not be considered as part of the key. More specifically, regexes and buffers are keyed according to their
.toString(), and dates are keyed according to their
Keying of arrays (prototype
Array.prototype), POJOs (prototype
Object.prototype), and prototype-less objects (prototype
null) works according to their enumerable and non-enumerable property names and symbols and their values, without regard to the order they appear.
Other objects are by default simply keyed according to their identity (i.e.,
===), although this can be extended (see
Take a look at the unit tests in
test.js for some specific examples of what will and will not get keyed the same way.
const memoizedFunction =// or
All memoized values for a function can be cleared by calling
clear on the original function or on the memoized function. These do exactly the same thing: Since all memoized copies of the same function share the same cache, clearing one clears all of them.
This makes keying of instances of
Class2, etc. work the same as arrays, POJOs, and prototype-less objects. That is, keyed according to their prototype and their enumerable and non-enumerable property names and symbols and their values, without regard to the order they appear. Note that this only sets up handling for direct instances of
Class1, etc. (i.e., those objects whose prototype is
This allows more customization of how instances of
Class2, etc. are keyed. In general, keying objects involves converting them into a linear array of primitives and objects to use as
WeakMap keys. Two objects will be keyed together if and only if they are converted to arrays of the same (
===) primitives and objects.
A custom handler is implemented by writing a function that accepts three arguments:
obj (the object to compute the representation for),
push (a function to be called with one or more primitives or objects to append to the representation for this object), and
recurse (a function to be called to insert the representation for another object). Take a look at the implementations of the existing handlers in
handlers.js for more details on how these could work.
const memoizedFunction =memoizedFunctionoriginal === originalFunction // true
The original function is available as the
.original property on the memoized function.
Copyright (c) 2018 Conduitry