refactored from ES6 classes to factory function to Queue Data Strucutre

Author: crizstian

05-chapter-Queue/index.js

@@ -0,0 +1,4 @@
+(function (exports) {
+  const {queue} = require('./queue.module')
+  Object.assign(exports, {queue})
+}((typeof module.exports !== undefined) ? module.exports : window))

05-chapter-Queue/queue.module.js

@@ -0,0 +1,23 @@
+(function (exports) {
+  const queue = (data = []) => {
+    let dataStore = data
+
+    const queueProto = {
+      enqueue: (element) => dataStore.push(element),
+      dequeue: () => dataStore.shift(),
+      front: () => dataStore[0],
+      back: () => dataStore[dataStore.length - 1],
+      isEmpty: () => dataStore.length === 0,
+      length: () => dataStore.length,
+      getQueue: () => dataStore,
+      setQueue: (data) => {
+        dataStore = data
+      },
+      toString: () => JSON.stringify(dataStore, null, 2)
+    }
+
+    return Object.create(queueProto)
+  }
+
+  Object.assign(exports, {queue})
+}((typeof module.exports !== undefined) ? module.exports : window))

05-chapter-Queue/readme.md

@@ -0,0 +1,25 @@
+# Queue with ES6
+
+### Code Examples
+- [Queue Data Structure](./queue.module.js)
+- [Import Module](./index.js)
+
+### Description
+A queue is a type of list where data are inserted at the end and are removed from the front. Queues are used to store data in the order in which they occur, as opposed to a stack, in which the last piece of data entered is the first element used for processing. Think of a queue like the line at your bank, where the first person into the line is the first person served, and as more customers enter a line, they wait in the back until it is their turn to be served.
+
+A queue is an example of a first-in, first-out (FIFO) data structure. Queues are used to order processes submitted to an operating system or a print spooler, and simulation applications use queues to model scenarios such as customers standing in the line at a bank or a grocery store.
+
+![](https://cdn-images-1.medium.com/max/800/0*SFoM_gyGXk8MIfl4.png)
+
+common operations you can perform on graphs:
+- `enqueue`: adds a new element to the queue at the last position
+- `dequeue`: remove the first item from the queue
+- `front`: returns the first item pushed to queue
+- `back`: returns the last item pushed to queue
+- `length`: returns the size of the queue
+- `isEmpty`: returns true if the queue has elements or false if it has no elements
+- `getQueue`: returns the data of the queue
+
+### Example use cases
+- Resolving simultaneous server requests from multiple users, such as 3 people buying the last ticket for a plane at almost the same time
+- Queuing up data during a breadth-first search.

05-chapter-Queue/test.js

@@ -0,0 +1,86 @@
+const {queue} = require('./index')
+
+test('Queue test 1', assert => {
+  const patient = (name = 'generic', code = '0') => Object.assign({}, {name, code})
+
+  const ed = queue()
+  const p = patient('Smith', 5)
+  ed.enqueue(p)
+  const p2 = patient('Jones', 4)
+  ed.enqueue(p2)
+  const p3 = patient('Fehrenbach', 6)
+  ed.enqueue(p3)
+  const p4 = patient('Brown', 1)
+  ed.enqueue(p4)
+  const p5 = patient('Ingram', 1)
+  ed.enqueue(p5)
+
+  const dequeue = function () {
+    let priority = this.front().code
+    let position = 0
+    let dataStore = this.getQueue()
+    for (let i = 0; i < this.length(); i++) {
+      if (dataStore[i].code >= priority) {
+        priority = dataStore[i].code
+        position = i
+      }
+    }
+    return dataStore.splice(position, 1)
+  }
+
+  Object.assign(ed, {dequeue})
+
+  let seen = []
+
+  while (ed.length() > 0) {
+    let {name} = ed.dequeue()[0]
+    seen.push(name)
+    // console.log('\nPatient being treated: ' + seen[seen.length - 1])
+  }
+
+  assert.equal(seen[0], 'Fehrenbach', 'dequeue fn override and dequeue by code')
+})
+
+test('Queue test 2', assert => {
+  function isPalindrome (word) {
+    const letter = new RegExp('[a-z]')
+    let palindrome = word.toLowerCase().split('')
+    let a, b
+    palindrome = palindrome.filter(item => letter.test(item))
+    const q = queue(palindrome)
+
+    const dequeueBack = function (element) {
+      const dataStore = this.getQueue()
+      const data = dataStore.unshift(element)
+      this.setQueue(data)
+      return data
+    }
+
+    Object.assign(q, {dequeueBack})
+
+    while (!q.isEmpty()) {
+      if (q.length() > 1) {
+        a = q.front()
+        b = q.back()
+      } else {
+        // console.log(`The string '${word.toUpperCase()}' is palindrome!`)
+        return true
+      }
+      if (a === b && q.length() > 1) {
+        q.dequeue()
+        q.dequeueBack()
+      } else {
+        // console.log(`The string '${word.toUpperCase()}' is not palindrome!`)
+        return false
+      }
+    }
+  }
+
+  const word = 'racecar'
+  const word2 = 'A man, a plan, a canal: Panama'
+  const word3 = 'what is this'
+
+  assert.equal(true, isPalindrome(word), `the string = '${word}' is palindrome`)
+  assert.equal(true, isPalindrome(word2), `the string = '${word2}' is palindrome`)
+  assert.equal(false, isPalindrome(word3), `the string = '${word3}' is not a palindrome`)
+})