Skip to main content
100%

$.cacheFactory

✓ Published0🌍 Public
Aabernier
Last edited Sep 1, 2011
Created on Aug 13, 2011

This example demonstrates a reusable caching mechanism for asynchronous jQuery operations, specifically applied to script loading. It shows how the `$.cacheFactory` function wraps an arbitrary factory function—here, `$.cachedGetScript`—to memoize deferred promises keyed by URL. The code uses jQuery’s `$.Deferred`, `$.getScript`, and `.promise()` to ensure each script is fetched only once, while subsequent calls with the same URL receive the already-resolved promise and execute their callback immediately. The implementation relies on a plain JavaScript object as the cache store, with no external data source or rendering involved.

AI-generated description

Similar vizzes

Loading thumbnail…

async-cache-0.js

This example demonstrates a caching mechanism for asynchronous functions, showing how repeated calls can bypass a slow database lookup. It defines `cachify`, a wrapper that takes an original async function and a cache-fetching function, returning a new function to use instead. The code uses `setTimeout` to simulate random 1–2 second database delays and a near-instant cache response, with data stored in a plain in-memory `users` object. The example compares timing via `console.time` and `console.timeEnd`, illustrating the performance difference between direct database access and cached retrieval.

Aalessioalex
64% match
Loading thumbnail…

Demo of my strange caching strategy

This example demonstrates a caching strategy that stores promises instead of resolved data, ensuring that repeated requests for the same resource return the same in-flight promise. The code uses jQuery’s `ajax` method wrapped in a native `Promise` to fetch Star Wars character data from the SWAPI, with a `Cache` class exposing getters for Luke Skywalker and his homeworld, Tatooine. The getter for Tatooine chains off the Luke promise, and the demo logs responses from both cached entries, showing how dependent promises are reused without duplicate network calls.

Aalex-r-bigelow
63% match
Loading thumbnail…

0-cache-args.js

A JavaScript code example demonstrates a caching wrapper for asynchronous database calls. It shows a `cachify` function that intercepts a Node.js-style callback, first consulting an in-memory cache via `getResultFromCache`, and falling back to the original `getUserFromDb` on cache misses. The data source is a hardcoded `users` object, and timing via `console.time` illustrates the performance difference between direct database access (1–2 seconds) and cached retrieval (near-instant).

Aalessioalex
61% match
Loading thumbnail…

0-cache-second-try.js

This example demonstrates a caching pattern that wraps an asynchronous database lookup with a cache check, showing how repeated requests can bypass the original slow operation. The code defines an in-memory `users` object and a `getUserFromDb` function that simulates a 1–2 second delay using `setTimeout`. The `cachify` helper composes the original function with `getResultFromCache`, which returns the same user data synchronously via a zero-millisecond timeout. Two `console.time` calls compare the direct database hit against the cached call, visually timing the difference in the console.

Aalessioalex
60% match
Loading thumbnail…

Gist 89193bd17e57c1339fdc4888b072d7ed

This example visualizes the caching behavior of a JavaScript `memoize` function. It shows how repeated calls with the same argument return a cached result, while new arguments trigger a fresh computation and expand the internal cache object. The code implements the memoization pattern manually, using a plain object as a cache and the spread operator to merge new entries. It does not rely on external libraries or rendering APIs; the visualization likely depicts the function’s execution flow and cache state changes, though the specific display mechanism is not defined in the provided source. The data originates from the `memoize.js` file, demonstrating the logic in isolation.

RRestuta
60% match
Loading thumbnail…

Gist 6547269

This example shows a caching layer for the npm registry, which retrieves package metadata documents and keeps them in a local LRU cache. It demonstrates how to use the `lru-cache` module for in-memory storage, `couchwatch` to subscribe to real-time changes from the CouchDB-based registry database at `http://isaacs.iriscouch.com/registry`, and `request` to fetch individual package documents on cache misses. When a change row arrives, the corresponding cache entry is deleted, ensuring the cache stays fresh. The code defines a `RegistryCache` constructor with a `get` method that returns cached data or fetches it via HTTP, handling errors and non-200 responses.

Aalessioalex
55% match
Loading thumbnail…

deferred smileys

This example demonstrates a minimal asynchronous workflow using jQuery’s Deferred object. It schedules a two-second timeout, then resolves or rejects a promise based on the current timestamp: if `Date.now()` returns a truthy value (which it always does), the deferred resolves with a smiley `:)`; otherwise it rejects with `:(`. The chained `.then()` and `.fail()` callbacks log the resulting message to the console. The code uses `$.Deferred`, `setTimeout`, and promise methods to illustrate deferred handling, with no external data sources or rendering.

Aabernier
54% match
Loading thumbnail…

$.loadTmpl

This example demonstrates a lightweight jQuery plugin that loads an external HTML template and injects it into the document head as a script tag with a custom type. It uses the jQuery `$.get` method to fetch the template content, then appends it using the `$("head").append()` API. The plugin assigns the template a user-specified id and type `text/template`, making it available for client-side rendering without executing the content. The code shows a simple, reusable pattern for loading templates dynamically, relying on jQuery’s AJAX and DOM manipulation functions.

Aabernier
54% match