typescript-memoize

What is typescript-memoize?

The `typescript-memoize` package provides decorators for memoizing methods in TypeScript. Memoization is a technique used to speed up function calls by caching the results of expensive function calls and returning the cached result when the same inputs occur again.

What are typescript-memoize's main functionalities?

Basic Memoization

This feature allows you to memoize a method so that the result is cached based on the input parameters. The second call with the same input will return the cached result without recomputing.

class Example {
  @Memoize()
  computeExpensiveValue(input: number): number {
    console.log('Computing...');
    return input * 2; // Simulate an expensive computation
  }
}

const example = new Example();
console.log(example.computeExpensiveValue(5)); // Computing... 10
console.log(example.computeExpensiveValue(5)); // 10 (cached result)

Custom Cache Key

This feature allows you to specify a custom cache key for the memoization. This can be useful if you need more control over how the cache keys are generated.

class Example {
  @Memoize((input: number) => `key-${input}`)
  computeExpensiveValue(input: number): number {
    console.log('Computing...');
    return input * 2; // Simulate an expensive computation
  }
}

const example = new Example();
console.log(example.computeExpensiveValue(5)); // Computing... 10
console.log(example.computeExpensiveValue(5)); // 10 (cached result)

Expiration Time

This feature allows you to set a time-to-live (TTL) for the cached result. After the TTL expires, the cached result will be invalidated, and the method will be recomputed.

class Example {
  @Memoize({ ttl: 5000 })
  computeExpensiveValue(input: number): number {
    console.log('Computing...');
    return input * 2; // Simulate an expensive computation
  }
}

const example = new Example();
console.log(example.computeExpensiveValue(5)); // Computing... 10
setTimeout(() => {
  console.log(example.computeExpensiveValue(5)); // Computing... 10 (cache expired)
}, 6000);

Other packages similar to typescript-memoize

lodash

Lodash is a popular utility library that provides a wide range of functions, including memoization. The `_.memoize` function in Lodash can be used to memoize functions, but it does not provide decorators out of the box. Lodash is more general-purpose and includes many other utilities beyond memoization.

memoizee

Memoizee is a dedicated memoization library for JavaScript. It offers a rich set of features for memoizing functions, including support for custom cache keys, expiration times, and more. Unlike `typescript-memoize`, it does not provide decorators specifically for TypeScript.

moize

Moize is another memoization library that offers a wide range of configuration options, including custom cache keys, expiration times, and more. It is designed to be highly configurable and performant. Like `memoizee`, it does not provide TypeScript decorators but can be used in TypeScript projects.

README

The README file is missing