# Javascript Cheat Sheet
## Arrays
### Split Array into chunks
#### Usage
```javascript
let someArray = [1, 2]
let chunkSize = 10
let chunks = chunk(someArray, chunkSize)
```
#### Code
```javascript
const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
```
### Async/Await batching of Array
#### Description
It runs batches synchronously, but async for each item in a batch

#### Code
```javascript
let batches = chunk(myArray, 10)
for(let batch of batches){
  await Promise.all(batch.map(async(item) => {
    await doSomeAsyncStuffForEachItemInBatch(item);
  }));
})
```
## Refactorings
### Switch Statements
#### Description
You have a switch statement, but it is ugly and not easy to maintain.
#### Code
```javascript
// 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'
```
## Design Patterns
### Chain of Responsibility
#### Use cases
* 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

#### Code
```javascript
// 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);
```