feat: add chapter3, chapter4 and chapter5 exercises

Author: ignatij

chapter3-callbacks/3.2/index.js

@@ -0,0 +1,38 @@
+const { EventEmitter } = require("events");
+
+const ticker = (time, cb) => {
+  const emitter = new EventEmitter();
+  let ticks = 0;
+  process.nextTick(() => emitter.emit("start"));
+  if (time % 5 === 0) {
+    emitter.emit("error", "Dividing by 5");
+    return
+  }
+
+  const interval = setInterval(() => {
+    if (Date.now() % 5 === 0) {
+      emitter.emit("error", "Dividing by 5");
+    }
+    emitter.emit("tick");
+    ticks++;
+  }, 50);
+  setTimeout(() => {
+    clearInterval(interval);
+    cb(ticks);
+  }, time);
+  return emitter;
+};
+
+const emitter = ticker(324, (ticks) => {
+  console.log("total number of ticks ", ticks);
+});
+emitter.on("tick", () => {
+  console.log("tick");
+});
+
+emitter.on("start", () => {
+  console.log("start called");
+});
+emitter.on("error", (e) => {
+  console.error("Error happened", e);
+});

chapter4-async-control-flow/4.2/index.js

@@ -0,0 +1,70 @@
+"use strict";
+const fs = require("fs");
+const path = require("path");
+
+let running = 1;
+const result = [];
+const listNestedFiles = (dir, cb) => {
+  if (running === 0) {
+    return cb(null, result);
+  }
+  fs.readdir(dir, "utf-8", (err, files) => {
+    if (err) {
+      return cb(err);
+    }
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      fs.lstat(dir + "/" + file, (err, stats) => {
+        if (err) {
+          return cb(err);
+        }
+        if (stats.isDirectory()) {
+          running++;
+          process.nextTick(() => listNestedFiles(dir + "/" + file, cb));
+        } else {
+          result.push(file);
+        }
+        if (i === files.length - 1) {
+          running--;
+        }
+        if (i === files.length - 1 && running === 0) {
+          cb(null, result);
+        }
+      });
+    }
+  });
+};
+
+const listNestedFilesPromisified = async (dir, cb) => {
+  try {
+    const result = await recursivelyFind(dir);
+    return cb(null, result.flat(Infinity));
+  } catch (err) {
+    cb(err);
+  }
+};
+
+const fsPromisified = require("fs/promises");
+const recursivelyFind = async (dir) => {
+  try {
+    const files = await fsPromisified.readdir(dir, "utf-8");
+    return Promise.all(
+        files.map((file) => recursivelyFind(path.join(dir, file)))
+    );
+  } catch (err) {
+    if (err.code === "ENOTDIR") {
+      return path.basename(dir);
+    }
+    throw new Error("Somethin went wrong ", err);
+  }
+};
+
+listNestedFilesPromisified(
+  "../",
+  (err, dat) => {
+    if (err) {
+      console.log(err);
+    }
+    console.log(dat.length);
+  }
+);

chapter4-async-control-flow/4.3/index.js

@@ -0,0 +1,84 @@
+"use strict";
+const fs = require("fs");
+const path = require("path");
+
+const result = [];
+let running = 1;
+const recursiveFind = (dir, keyword, cb) => {
+  fs.readdir(dir, "utf-8", (err, files) => {
+    if (err) {
+      return cb(err);
+    }
+    files.forEach((file, index) => {
+      fs.lstat(path.join(dir, file), (err, stats) => {
+        if (err) {
+          return cb(err);
+        }
+        if (stats.isDirectory()) {
+          running++;
+          process.nextTick(() =>
+            recursiveFind(path.join(dir, file), keyword, cb)
+          );
+          if (index === files.length - 1) {
+            running--;
+          }
+        } else {
+          fs.readFile(path.join(dir, file), "utf-8", (err, data) => {
+            if (err) {
+              return cb(err);
+            }
+            if (data.includes(keyword)) {
+              result.push(path.join(dir, file));
+            }
+            if (index === files.length - 1) {
+              running--;
+            }
+            if (index === files.length - 1 && running === 0) {
+              return cb(null, result);
+            }
+          });
+        }
+      });
+    });
+  });
+};
+
+const fsPromisified = require("fs/promises");
+const promisifiedRecursiveFind = async (dir, keyword, cb) => {
+  try {
+    const result = await recursive(dir, keyword);
+    return cb(null, result.flat(Infinity).filter(Boolean));
+  } catch (err) {
+    return cb(err);
+  }
+};
+
+const recursive = async (dir, keyword) => {
+  try {
+    const files = await fsPromisified.readdir(dir, "utf-8");
+    return Promise.all(
+      files.map((file) => recursive(path.join(dir, file), keyword))
+    );
+  } catch (err) {
+    if (err.code === "ENOTDIR") {
+      const content = await fsPromisified.readFile(dir, "utf-8");
+      if (content.includes(keyword)) {
+        return dir;
+      }
+    } else {
+      throw err;
+    }
+  }
+};
+
+promisifiedRecursiveFind(
+  "../",
+  "Batman",
+  (err, data) => {
+    if (err) {
+      console.log(err);
+    } else {
+      console.log(data);
+    }
+  }
+);

chapter4-async-control-flow/test1/baz.txt

@@ -0,0 +1,3 @@
+asdasd
+Batman
+asdasd

chapter4-async-control-flow/test1/foo.txt

@@ -0,0 +1 @@
+Batman

chapter4-async-control-flow/test2/bar.txt

@@ -0,0 +1 @@
+asdasd

chapter5-async-control-patterns/5.1/index.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const promiseAll = (promises) => {
+   return new Promise(async (resolve, reject) => {
+        const arr = []
+        for(let i = 0; i < promises.length; i++) {
+            try {
+                const curr = await promises[i]
+                arr.push(curr)
+            }
+            catch(err) {
+                return reject(err)
+            }
+        }
+        resolve(arr)
+   })
+}
+
+const a = () => {
+    return Promise.resolve('a')
+}
+
+const b = () => {
+    return Promise.resolve('b')
+}
+
+const c = () => {
+    return Promise.reject(new Error("Error happened"))
+}
+
+promiseAll([a(), b(), c()])
+    .then((data) => console.log(data))
+    .catch(e => {
+        console.error(e)
+    })

chapter5-async-control-patterns/5.2/index.js

@@ -0,0 +1,72 @@
+'use strict'
+const { EventEmitter } = require('events')
+
+class TaskQueue extends EventEmitter {
+    constructor(concurrent) {
+      super();
+      this.concurrent = concurrent;
+    }
+  
+    queue = [];
+    concurrent = 0;
+    running = 0;
+  
+    addTask(task) {
+      return new Promise((resolve, reject) => {
+        this.queue.push(async () => {
+            try {
+                const curr = await task()
+                return resolve(curr)
+            }
+            catch(err) {
+                return reject(err)
+            }
+        });
+        this.next()
+      });
+    }
+  
+    async next() {
+      while (this.running < this.concurrent && this.queue.length !== 0) {
+        const curr = this.queue.shift();
+        try {
+            await curr()
+        }
+        finally {
+            this.running--;
+            this.next();
+        }
+        this.running++;
+      }
+    }
+  }
+
+
+const delay = (ms) => {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => resolve(), ms)
+    })
+}
+
+const taskA = async () => {
+    console.log("starting task a")
+    await delay(5000)
+    return Promise.resolve('a')
+}
+
+const taskB = async () => {
+    console.log("starting task b")
+    await delay(1000)
+    return Promise.resolve('b')
+}
+
+const taskC = async () => {
+    console.log("starting task c")
+    await delay(2000)
+    return Promise.resolve('c')
+}
+
+const queue = new TaskQueue(2)
+queue.addTask(taskA).then(data => console.log(data))
+queue.addTask(taskB).then(data => console.log(data))
+queue.addTask(taskC).then(data => console.log(data))