https://github.com/wjsc/hold-on
Returns a function execution result or a cached result
https://github.com/wjsc/hold-on
memoization
Last synced: 5 months ago
JSON representation
Returns a function execution result or a cached result
- Host: GitHub
- URL: https://github.com/wjsc/hold-on
- Owner: wjsc
- License: mit
- Created: 2019-07-18T19:56:53.000Z (almost 6 years ago)
- Default Branch: master
- Last Pushed: 2022-12-30T18:17:21.000Z (over 2 years ago)
- Last Synced: 2024-11-06T16:57:05.335Z (6 months ago)
- Topics: memoization
- Language: JavaScript
- Size: 181 KB
- Stars: 3
- Watchers: 1
- Forks: 0
- Open Issues: 7
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://nodei.co/npm/@wjsc/hold-on)
# Hold-on
## Use case
This package can be used in this scenario
1. You have a costly function: time consuming, heavy CPU or IO usage
2. You need to perform that function frequently
3. The result of your function can change over time
4. You can tolerate some -configurable- inconsistency
5. You want to optimize that process
## How it works
It stores in memory the result of your function for immediate access, and clears that memory after a specified time.
It returns a function that can be used instead your original one.
```
const hold = require('@wjsc/hold-on');
const myOptimizedFunction = hold(,
## Usage
#### 1. First example
```
const hold = require('@wjsc/hold-on');
// Define your costly function: Let's supose it's so heavy!
const myFunction = () => new Date();
// Make a new version of your function with 500 ms cache
const myOptimizedFunction = hold(myFunction, 500);
// This code will execute new Date() only once
for(let i = 0; i<50; i++){
// And it prints always the same date
console.log(myOptimizedFunction());
}
```
#### 2. Second example: Retrieving a remote resource
```
const hold = require('@wjsc/hold-on');
// Any HTTP client
const fetch = require('node-fetch');
const myFunction = () => fetch('https://httpstat.us/200')
.then(res => res.text());
const myOptimizedFunction = hold(myFunction, 5000);
// This code will execute the HTTP GET only once
for(let i = 0; i<50; i++){
myOptimizedFunction()
.then(console.log);
}
// If you call the function after 5000 ms
// the request will be executed again
```
#### 3. Third example: Cache file from local storage
```
const hold = require('@wjsc/hold-on');
const fs = require('fs');
const myFunction = () => new Promise((resolve, reject) => {
fs.readFile('./my-file', 'utf8', (err, data) =>
err ? reject(err) : resolve(data)
)
})
const myOptimizedFunction = hold(myFunction, 5000);
myOptimizedFunction().then(console.log);
```
#### 4. Fourth example: It's also great to cache a file from a remote Storage such as S3
```
const hold = require('@wjsc/hold-on');
const aws = require('aws-sdk');
aws.config.update({
secretAccessKey: 'ABCDE',
accessKeyId: '12345'
})
const s3 = new aws.S3();
const myFunction = () => {
return new Promise((resolve, reject) => {
s3.getObject({
Bucket: 'my-bucket',
Key: 'my-file'
}, (err, data) => {
if ( err ) reject(err)
else resolve(data.Body.toString())
})
})
}
const myOptimizedFunction = hold(myFunction, 5000);
myOptimizedFunction().then(console.log);
```
## 100% Tested Library
Every line of code is tested
https://github.com/wjsc/hold-on/blob/master/test/index.test.js
## Tiny size
Less than 20 lines of code and no dependencies
## Advanced
#### How to force termination
This function uses setTimeout to clear the internal cache. In some cases, you may need to clear this timer.
This can be usefull if you are running a script that doesn't end at desired time, or if you want to terminate a background timer.
```
const myFunction = () => {};
const myOptimizedFunction = hold(myFunction, 100000000);
clearInterval(myOptimizedFunction.interval);
```
#### How to clear the memory cache
Just use the original function, or create a new function version.
Package name reference: https://www.youtube.com/watch?v=WPnOEiehONQ