Does not mutate the original array
let someArray = [1, 2]
let chunkSize = 10
let chunks = chunk(someArray, chunkSize)const chunk = (collection, length) => collection.length === 0
? []
: [collection.slice(0, length)].concat(chunk(collection.slice(length), length));or a more compact one-liner
const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));It runs batches synchronously, but async for each item in a batch
let batches = chunk(myArray, 10)
for(let batch of batches){
await Promise.all(batch.map(async(item) => {
await doSomeAsyncStuffForEachItemInBatch(item);
}));
})You have a switch statement, but it is ugly and not easy to maintain.
// You declare a function that can return a specified key or a default value and curry the hell out of it
const switchCase = cases => defaultCase => key =>
cases.hasOwnProperty(key) ? cases[key] : defaultCase;
// you can then declare your cases with a default like so
const mySwitchCases = switchCase({
101: 'one-o-one',
102: 'one-o-two'
})('defaultValue');
// you can then use it as such
let text = mySwitchCases(101); // '101'
let text = mySwitchCases(100000); // 'defaultValue'- When there are multiple handlers for a request but you are unsure of which one will handle the request
- When there is a list of handlers that should handle a request
- Handlers are dynamically defined
// Handler Super Class
class RequestHandler {
constructor(){
this.next = {
console.log('End of pipeline');
return Promise.resolve();
}
}
setNext(next){
this.next = next;
return next;
}
async handleRequest(request){}
}
// Some handler
class MyHandler extends RequestHandler{
constructor(someDependency){
super();
this.something = someDependency;
}
// Super class override
async handleRequest(request){
// do something here
// if you want to stop the pipeline, return, otherwise pass request to next
// This is not needed if you want all handlers to receive the request
if (shouldStopHere)
return;
await this.next.handleRequest(request);
}
}
// How to use
// Declare all your handlers, they can be different handlers, as long as they extend RequestHandler
let myHandler = new MyHandler(someDependency);
let mySecondHandler = new MyHandler(someDependecy);
let myThirdHandler = new MyOtherHandler();
// Define the order in which the handlers will execute ie. pipeline
myHandler
.setNext(mySecondHandler)
.setNext(myThirdHandler);
// Start the pipeline
myHandler.handleRequest(someRequest);