awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
alexreardon avatar

alexreardon/memoize-one

0
View on GitHub↗
2,971 stars·80 forks·TypeScript·MIT·21 views

Memoize One

Memoize-one is a JavaScript function memoization library that stores function return values and serves them instantly on repeat calls with identical arguments to avoid redundant calculations. It retains only the single most recent argument set and return value, maintaining a constant and bounded memory footprint.

The library features a shallow argument comparison engine and includes the runtime execution context alongside input arguments during comparison to ensure state and binding changes trigger fresh computations. Users can inject custom equality functions to override the default argument matching strategy for advanced validation and fine-grained cache control. Additionally, it provides methods to clear stored cache entries on demand to release memory and force fresh execution on subsequent function calls.

Features

  • Last-Result Caches - Store function output values to serve them instantly on repeat calls with identical arguments and avoid redundant calculations.
  • Method Result Caches - Caching the return values of expensive JavaScript functions to avoid redundant calculations during repeat calls.
  • Custom Equality Comparators - Configure custom comparison rules to replace default strict checks and determine whether inputs match using tailored logic.
  • Custom Comparison Logic - Accept custom equality logic to determine whether input arguments match previous invocations for fine-grained cache control.
  • Custom Equality Definitions - Accepts an optional user-defined comparison function to override the default argument matching strategy for advanced validation.
  • Function Result Memoization - A function memoization library that remembers only the latest invocation and result to avoid redundant calculations with minimal memory usage.
  • Context Memoization - Includes the execution context alongside input arguments during comparison to ensure state changes trigger fresh computations.
  • Least Recently Used Caches - Retains only the single most recent argument set and return value, keeping memory usage constant and bounded.
  • Function Result Caching - Wipe stored results on demand to free memory and force the wrapped function to recompute on the next invocation.
  • Function Context Binding - Includes the runtime context alongside input arguments during comparison to ensure binding changes trigger fresh computations.
  • Memoization Caches - Reset stored cache entries to release memory and force fresh execution on subsequent function calls.
  • Execution Context Tracking - Include the runtime execution context during argument checks so changes to bindings trigger fresh calculations.
  • React Hook Optimizations - Preventing unnecessary recalculations and re-renders in frontend applications by remembering the latest function outputs.

Star history

Star history chart for alexreardon/memoize-oneStar history chart for alexreardon/memoize-one

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Curated searches featuring Memoize One

Hand-picked collections where Memoize One appears.
  • Function execution tracer

Frequently asked questions

What does alexreardon/memoize-one do?

Memoize-one is a JavaScript function memoization library that stores function return values and serves them instantly on repeat calls with identical arguments to avoid redundant calculations. It retains only the single most recent argument set and return value, maintaining a constant and bounded memory footprint.

What are the main features of alexreardon/memoize-one?

The main features of alexreardon/memoize-one are: Last-Result Caches, Method Result Caches, Custom Equality Comparators, Custom Comparison Logic, Custom Equality Definitions, Function Result Memoization, Context Memoization, Least Recently Used Caches.

Which projects share features with alexreardon/memoize-one?

Projects with overlapping indexed features include: tc39/proposal-signals — This project is an ECMAScript proposal to introduce a native reactive state primitive to the JavaScript language. It… angus-c/just — Just is a collection of JavaScript utility libraries designed for data manipulation, functional programming,… mgechev/angular-performance-checklist — This project is a technical reference and guide for optimizing the performance of Angular applications. It provides a… benjamine/jsondiffpatch — jsondiffpatch is a JSON diff and patch library designed to calculate differences between two JSON objects and apply… grantjenks/python-diskcache — This project is a disk-backed key-value store and persistent data structure library for Python. It provides a… reactjs/react.dev — React is a JavaScript library for building user interfaces through the composition of modular, self-contained…

Projects sharing features with Memoize One

These projects share indexed features with Memoize One. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • tc39/proposal-signalstc39 avatar

    tc39/proposal-signals

    4,138View on GitHub↗

    This project is an ECMAScript proposal to introduce a native reactive state primitive to the JavaScript language. It defines a standard for fine-grained reactivity, providing a mechanism to track value dependencies and automatically propagate updates through a dependency graph. The specification focuses on managing computed values and side effects based on granular changes to state. It enables the synchronization of state updates across a dependency graph and the tracking of relationships between values and their observers without manual subscriptions. The proposal covers efficient value com

    View on GitHub↗4,138
  • angus-c/justangus-c avatar

    angus-c/just

    6,204View on GitHub↗

    Just is a collection of JavaScript utility libraries designed for data manipulation, functional programming, performance optimization, statistical analysis, and string processing. It provides a set of tools for deep cloning, filtering, and transforming complex objects and arrays. The project is structured as a series of zero-dependency modules, allowing utilities to be used independently to minimize bundle size. It implements functional programming patterns including currying, piping, and partial application, and provides execution control through memoization, debouncing, and throttling. The

    JavaScript
    View on GitHub↗6,204
  • mgechev/angular-performance-checklistmgechev avatar

    mgechev/angular-performance-checklist

    4,134View on GitHub↗

    This project is a technical reference and guide for optimizing the performance of Angular applications. It provides a comprehensive checklist for improving speed and efficiency by focusing on bundle optimization, rendering best practices, and runtime execution. The guide covers a wide array of differentiators including the implementation of progressive web app strategies through service workers and offline caching. It also details methods for improving perceived load times using server-side rendering and application shells. The repository provides guidance on broader capability areas such as

    View on GitHub↗4,134
  • benjamine/jsondiffpatchbenjamine avatar

    benjamine/jsondiffpatch

    5,324View on GitHub↗

    jsondiffpatch is a JSON diff and patch library designed to calculate differences between two JSON objects and apply those changes to synchronize states. It functions as a synchronization tool for computing deltas and applying patches to update or revert complex nested JavaScript objects. The project provides a standard-compliant implementation of RFC 6902 JSON Patch for atomic updates and a visual difference renderer that converts data deltas into human-readable HTML views. It includes a specialized text diff tool for performing fine-grained, character-level analysis on long strings within JS

    TypeScript
    View on GitHub↗5,324
Compare all 30 related projects→