wjvander · April 4, 2018 10:37 · Apr 4, 2018 · Apr 4, 2018 · Mar 8, 2018 · Mar 8, 2018
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -5,7 +5,7 @@ Waits a certain amount of time, then returns with a promise
 
 #### Code
 ```javascript
-let waitAWhile = (timeToWait) => new Promise((resolve, reject) => setTimeout(resolve, timeToWait));
+let waitAWhile = (timeToWait) => new Promise(resolve => setTimeout(resolve, timeToWait));
 ```
 
 ## Arrays

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -1,4 +1,13 @@
 # Javascript Cheat Sheet
+## Snippets
+### Promise Delay
+Waits a certain amount of time, then returns with a promise
+
+#### Code
+```javascript
+let waitAWhile = (timeToWait) => new Promise((resolve, reject) => setTimeout(resolve, timeToWait));
+```
+
 ## Arrays
 ### Split Array into chunks
 Does not mutate the original array

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -2,12 +2,7 @@
 ## Arrays
 ### Split Array into chunks
 Does not mutate the original array
-#### Usage
-```javascript
-let someArray = [1, 2]
-let chunkSize = 10
-let chunks = chunk(someArray, chunkSize)
-```
+
 #### Code
 ```javascript
 const chunk = (collection, length) => collection.length === 0 
@@ -18,6 +13,12 @@ or a more compact one-liner
 ```javascript
 const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
 ```
+#### Usage
+```javascript
+let someArray = [1, 2]
+let chunkSize = 10
+let chunks = chunk(someArray, chunkSize)
+```
 ### Async/Await batching of Array
 #### Description
 It runs batches synchronously, but async for each item in a batch.

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -95,8 +95,8 @@ const mySwitchCases = switchCase({
 })('defaultValue');
 
 // you can then use it as such
-let text = mySwitchCases(101); // '101'
-let text = mySwitchCases(100000); // 'defaultValue'
+let text = mySwitchCases('101'); // 'one-o-one'
+let text = mySwitchCases('100000'); // 'defaultValue'
 ```
 ## Design Patterns
 ### Chain of Responsibility

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -35,7 +35,7 @@ for(let batch of batches){
 ## Refactorings
 ### Switch Statements
 #### Description
-You have a switch statement, but it is ugly and not easy to maintain.
+You have a `switch` statement, but it is ugly and not easy to maintain.
 #### Original
 ```javascript
 let mySwitchCase = (code) => {

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -21,7 +21,7 @@ const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.sli
 ### Async/Await batching of Array
 #### Description
 It runs batches synchronously, but async for each item in a batch.
-Might be a good idea to just do a `try catch` inside the `map`.
+Might be a good idea to just do a `try...catch` inside the `map`.
 
 #### Code
 ```javascript

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -20,7 +20,8 @@ const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.sli
 ```
 ### Async/Await batching of Array
 #### Description
-It runs batches synchronously, but async for each item in a batch
+It runs batches synchronously, but async for each item in a batch.
+Might be a good idea to just do a `try catch` inside the `map`.
 
 #### Code
 ```javascript

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -80,6 +80,8 @@ let text = myCases('10000'); // defaultValue
 #### Attempt 3
 So I like the idea of an object lookup and wrapping it in a function, which is fine for one case, but if I have multiple of these, I have to keep writing the function, the cases and the logic check...this smells a bit.
 So I can extract it even more, so that the logic is only written once for each switch case.
+
+This also means that the cases no longer have to be hard coded, we could load them from a JSON file, dynamically create them etc. This gives us a lot more flexible 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 =>

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -35,16 +35,60 @@ for(let batch of batches){
 ### Switch Statements
 #### Description
 You have a switch statement, but it is ugly and not easy to maintain.
-#### Code
+#### Original
+```javascript
+let mySwitchCase = (code) => {
+  switch (code) {
+    case '101': {
+      return 'one-o-one';
+    }
+    case '102': {
+      return 'one-o-two';
+    }
+    default: {
+      return 'defaultValue';
+    }
+  }
+}
+```
+#### Attempt 1
+You could turn it into an object lookup, but then it a default value would be more complicated
+```javascript
+let myCases = {
+'101': 'one-o-one',
+'102': 'one-o-two'
+};
+
+let text = myCases['101']; // one-o-one
+let text = myCases['10000'] || 'defaultValue'; // defaultValue
+```
+### Attempt 2
+I like the object lookup idea, but having to check if it returned a value each time just to declare a default is not nice. So I could wrap it in a function
+```javascript
+let myCases = (code) => {
+  let cases = {
+    '101': 'one-o-one',
+    '102': 'one-o-two'
+  };
+
+  return cases[code] || 'defaultValue';
+};
+
+let text = myCases('101'); // one-o-one
+let text = myCases('10000'); // defaultValue
+```
+#### Attempt 3
+So I like the idea of an object lookup and wrapping it in a function, which is fine for one case, but if I have multiple of these, I have to keep writing the function, the cases and the logic check...this smells a bit.
+So I can extract it even more, so that the logic is only written once for each switch case.
 ```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'
+  '101': 'one-o-one',
+  '102': 'one-o-two'
 })('defaultValue');
 
 // you can then use it as such

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -1,6 +1,7 @@
 # Javascript Cheat Sheet
 ## Arrays
 ### Split Array into chunks
+Does not mutate the original array
 #### Usage
 ```javascript
 let someArray = [1, 2]

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -13,6 +13,10 @@ const chunk = (collection, length) => collection.length === 0
   ? [] 
   : [collection.slice(0, length)].concat(chunk(collection.slice(length), length));
 ```
+or a more compact one-liner
+```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

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -9,7 +9,9 @@ let chunks = chunk(someArray, chunkSize)
 ```
 #### Code
 ```javascript
-const chunk = (collection, length) => collection.length === 0 ? [] : [collection.slice(0, length)].concat(chunk(collection.slice(length), length));
+const chunk = (collection, length) => collection.length === 0 
+  ? [] 
+  : [collection.slice(0, length)].concat(chunk(collection.slice(length), length));
 ```
 ### Async/Await batching of Array
 #### Description

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -9,7 +9,7 @@ let chunks = chunk(someArray, chunkSize)
 ```
 #### Code
 ```javascript
-const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
+const chunk = (collection, length) => collection.length === 0 ? [] : [collection.slice(0, length)].concat(chunk(collection.slice(length), length));
 ```
 ### Async/Await batching of Array
 #### Description

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -24,7 +24,26 @@ for(let batch of batches){
   }));
 })
 ```
+## 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

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -72,13 +72,16 @@ class MyHandler extends RequestHandler{
 }
 
 // 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(someOtherDependency);
+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);
 ```
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -74,8 +74,11 @@ class MyHandler extends RequestHandler{
 // How to use
 let myHandler = new MyHandler(someDependency);
 let mySecondHandler = new MyHandler(someDependecy);
+let myThirdHandler = new MyOtherHandler(someOtherDependency);
 
-myHandler.setNext(mySecondHandler);
+myHandler
+  .setNext(mySecondHandler)
+  .setNext(myThirdHandler);
 
 myHandler.handleRequest(someRequest);
 ```
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -22,4 +22,60 @@ for(let batch of batches){
   await Promise.all(batch.map(async(item) => {
     await doSomeAsyncStuffForEachItemInBatch(item);
   }));
-})
+})
+```
+
+## 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
+let myHandler = new MyHandler(someDependency);
+let mySecondHandler = new MyHandler(someDependecy);
+
+myHandler.setNext(mySecondHandler);
+
+myHandler.handleRequest(someRequest);
+```
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -16,7 +16,7 @@ const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.sli
 It runs batches synchronously, but async for each item in a batch
 
 #### Code
-```javascrip
+```javascript
 let batches = chunk(myArray, 10)
 for(let batch of batches){
   await Promise.all(batch.map(async(item) => {

diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -11,3 +11,15 @@ let chunks = chunk(someArray, chunkSize)
 ```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
+```javascrip
+let batches = chunk(myArray, 10)
+for(let batch of batches){
+  await Promise.all(batch.map(async(item) => {
+    await doSomeAsyncStuffForEachItemInBatch(item);
+  }));
+})
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -2,12 +2,12 @@
 ## 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));
 ```
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -2,9 +2,12 @@
 ## Arrays
 ### Split Array into chunks
 #### Usage
-```let someArray = [1, 2]
-   let chunkSize = 10
-   let chunks = chunk(someArray, chunkSize)
+```
+let someArray = [1, 2]
+let chunkSize = 10
+let chunks = chunk(someArray, chunkSize)
 ```
 #### Code
-`const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
+```
+const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
+```
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -5,6 +5,6 @@
 ```let someArray = [1, 2]
    let chunkSize = 10
    let chunks = chunk(someArray, chunkSize)
-
+```
 #### Code
-const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
+`const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -2,9 +2,9 @@
 ## Arrays
 ### Split Array into chunks
 #### Usage
-let someArray = [1, 2]
-let chunkSize = 10
-let chunks = chunk(someArray, chunkSize)
+```let someArray = [1, 2]
+   let chunkSize = 10
+   let chunks = chunk(someArray, chunkSize)
 
 #### Code
 const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));
diff --git a/javascriptCheatSheet.md b/javascriptCheatSheet.md
@@ -0,0 +1,10 @@
+# Javascript Cheat Sheet
+## Arrays
+### Split Array into chunks
+#### Usage
+let someArray = [1, 2]
+let chunkSize = 10
+let chunks = chunk(someArray, chunkSize)
+
+#### Code
+const chunk = (a, l) => a.length === 0 ? [] : [a.slice(0, l)].concat(chunk(a.slice(l), l));