Awesome Promise Methods

const promisify =
  (func) =>
  (...args) =>
    new Promise((resolve, reject) =>
      func(...args, (err, result) => (err ? reject(err) : resolve(result)))
    );

const delay = promisify((d, cb) => setTimeout(cb, d));
delay(2000).then(() => console.log("Hello World!"));

const util = require("util");
const fs = require("fs");

const stat = util.promisify(fs.stat);
stat(".")
  .then((stats) => {
    // 做你要做的事情
  })
  .catch((error) => {
    // 處理錯誤
  });

const util = require("util");
const fs = require("fs");

const stat = util.promisify(fs.stat);

async function callStat() {
  const stats = await stat(".");
  console.log(`This directory is owned by ${stats.uid}`);
}

const runAsync = (fn) => {
  const worker = new Worker(
    URL.createObjectURL(new Blob([`postMessage((${fn})());`]), {
      type: "application/javascript; charset=utf-8",
    })
  );
  return new Promise((res, rej) => {
    worker.onmessage = ({ data }) => {
      res(data), worker.terminate();
    };
    worker.onerror = (err) => {
      rej(err), worker.terminate();
    };
  });
};

const longRunningFunction = () => {
  let result = 0;
  for (let i = 0; i < 1000; i++) {
    for (let j = 0; j < 700; j++) {
      for (let k = 0; k < 300; k++) {
        result = result + i + j + k;
      }
    }
  }
  return result;
};
runAsync(longRunningFunction).then(console.log); // 209685000000
runAsync(() => 10 ** 3).then(console.log); // 1000

let outsideVariable = 50;
runAsync(() => typeof outsideVariable).then(console.log); // 'undefined'

const test = (time) =>
  new Promise((resolve) => {
    setTimeout(() => resolve(time), time);
  });

const temp = [test(1000), test(2000), test(3000)];

Promise.all(temp).then(console.log); // [1000, 2000, 3000]

const runPromisesInSeries = (ps) =>
  ps.reduce((p, next) => p.then(next), Promise.resolve());

const delay = (time) =>
  new Promise((resolve) => {
    console.log(time);
    setTimeout(resolve, time);
  });

const promiseSeries = [() => delay(1000), () => delay(2000)];

runPromisesInSeries(promiseSeries);

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function sleepyWork() {
  console.log("等一秒");
  await sleep(1000);
  console.log("一秒過去了");
}

const isPromiseLike = (obj) =>
  obj !== null &&
  (typeof obj === "object" || typeof obj === "function") &&
  typeof obj.then === "function";

const promise = new Promise((resolve) => {
  resolve();
});

isPromiseLike(promise); // true

isPromiseLike({
  then: function () {
    return "";
  },
}); // true
isPromiseLike(null); // false
isPromiseLike({}); // false

const fakePromise = {
  then: () => {},
};

isPromiseLike(fakePromise); // true