What is the most effective method for caching a getter function (excluding decorators)?

Question

What is the most effective method for caching a getter function (excluding decorators)?

Creating a getter cache can help optimize performance by storing and reusing the value rather than recalculating it each time. I am seeking the most efficient method to implement a getter cache without relying on decorators. While there are libraries that offer decorator solutions such as @cache, I prefer a more succinct approach with minimal typing.

Typescript playground

Here is an example:

type NoUndefined<T> = T extends undefined ? never : T;
function isNoUndefined <T> (value: T): value is NoUndefined<T> {
  return typeof value !== 'undefined'
}
function handleGetter <T>(value:T, operation: () => NoUndefined<T>): NoUndefined<T> {
  if (isNoUndefined(value)) return value;
  return operation()
}

class CalendarDate extends Date {
  #day: number | undefined = undefined
  get day () {
    return this.#day = handleGetter(this.#day, () => {
      console.log('runs once')
      return this.getDate()
    })
  }
}

const c = new CalendarDate()

c.day
c.day
c.day
c.day

typescript class caching getter

Answer 1

Answer №1

To implement a more efficient method, you can create a function that updates the getter in an existing class prototype with a new one wrapped in a smart/self-overwriting/lazy approach:

function updateGetter<T>(ctor: { prototype: T }, property: keyof T): void {
  const descriptor = Object.getOwnPropertyDescriptor(ctor.prototype, property);
  if (!descriptor) throw new Error("PROPERTY DESCRIPTOR NOT FOUND");
  const oldGetter = descriptor.get;
  if (!oldGetter) throw new Error("GETTER NOT DETECTED");
  Object.defineProperty(ctor.prototype, property, {
    get() {
      const result = oldGetter.call(this);
      Object.defineProperty(this, property, { value: result });
      return result;
    }
  })
}

By using

updateGetter(Class, "key")

, it accesses the property descriptor for Class.prototype.key. If any step fails, an error is thrown. Otherwise, a new getter is created which calls the original getter once on the current instance and caches the value directly on the instance instead of the prototype. This optimizes subsequent accesses to the property.

Test this implementation by applying it after declaring the class:

class TaskDeadline extends Date {
  get dueDate() {
    console.log('executes once');
    return this.getDate();
  }
}
updateGetter(TaskDeadline, "dueDate"); // <-- here

Ensure its functionality:

const firstTask = new TaskDeadline()
console.log(firstTask.dueDate); // executes once, 25
console.log(firstTask.dueDate); // 25
console.log(firstTask.dueDate); // 25
console.log(firstTask.dueDate); // 25


const secondTask = new TaskDeadline();
secondTask.setDate(10);
console.log(secondTask.dueDate) // executes once, 10
console.log(firstTask.dueDate) // 25
console.log(secondTask.dueDate) // 10

Validation successful.

This method provides a concise solution for users who prefer avoiding decorators. The decorator alternative likely follows a similar logic, acting as a wrapper for the property descriptor.

Playground link to code

Answer 2

To implement a more efficient method, you can create a function that updates the getter in an existing class prototype with a new one wrapped in a smart/self-overwriting/lazy approach:

function updateGetter<T>(ctor: { prototype: T }, property: keyof T): void {
  const descriptor = Object.getOwnPropertyDescriptor(ctor.prototype, property);
  if (!descriptor) throw new Error("PROPERTY DESCRIPTOR NOT FOUND");
  const oldGetter = descriptor.get;
  if (!oldGetter) throw new Error("GETTER NOT DETECTED");
  Object.defineProperty(ctor.prototype, property, {
    get() {
      const result = oldGetter.call(this);
      Object.defineProperty(this, property, { value: result });
      return result;
    }
  })
}

By using

updateGetter(Class, "key")

, it accesses the property descriptor for Class.prototype.key. If any step fails, an error is thrown. Otherwise, a new getter is created which calls the original getter once on the current instance and caches the value directly on the instance instead of the prototype. This optimizes subsequent accesses to the property.

Test this implementation by applying it after declaring the class:

class TaskDeadline extends Date {
  get dueDate() {
    console.log('executes once');
    return this.getDate();
  }
}
updateGetter(TaskDeadline, "dueDate"); // <-- here

Ensure its functionality:

const firstTask = new TaskDeadline()
console.log(firstTask.dueDate); // executes once, 25
console.log(firstTask.dueDate); // 25
console.log(firstTask.dueDate); // 25
console.log(firstTask.dueDate); // 25


const secondTask = new TaskDeadline();
secondTask.setDate(10);
console.log(secondTask.dueDate) // executes once, 10
console.log(firstTask.dueDate) // 25
console.log(secondTask.dueDate) // 10

Validation successful.

This method provides a concise solution for users who prefer avoiding decorators. The decorator alternative likely follows a similar logic, acting as a wrapper for the property descriptor.

Playground link to code

What is the most effective method for caching a getter function (excluding decorators)?

Answer №1

Similar questions

The element in TS 7023 is implicitly assigned an 'any' type due to the fact that an expression of type 'any' is not valid for indexing in type '{}'

The code executes smoothly on my local machine, but encounters an error on Heroku: [TypeError: An invalid character is present in the header content ["Authorization"]] {error code: 'ERR_INVALID_CHAR'}

An array that solely needs a single element to conform to a specific type

Converting Http Client GET response into an array of objects with specified type

Troubleshooting the issue with mocking the useTranslation function for i18n in JEST

The module has defined the component locally, however, it has not been made available for

What is the reason for the component property being valued within the subscribe body when it is not defined outside of it?

Can a standard tuple be matched with its corresponding key?

Enhancing TypeScript type definitions for the Response.render() method in Express

How can one assign a R6 object to a slot within an S4 object?

Checking Validity of an Array of URLs with Class-Validator

I'm experiencing a strange issue where my React component renders twice in production mode, despite having strict mode turned off. Can anyone advise me on

Python class peculiar characteristics

Define an object by extracting properties from an array of objects

Is it possible for a Firestore query using .where() to conduct a search with no results?

Issue with rendering classes in Next.js: Why is a class being inadvertently applied to a different element?

Conflicting prototypes of C++ classes

Is it possible to dynamically assign class properties from an array in JavaScript/TypeScript?

Create a CoffeeScript file and export a class from it

The natural elements are so minuscule they are practically nonexistent