Converting Callbacks to Promises in JavaScript

Converting Callbacks to Promises in JavaScript

Many older APIs (Node.js fs, crypto) are callback-based. You can convert them to promises with promisify or manually.

Manual Promisification

function promisify(fn) {
  return (...args) => {
    return new Promise((resolve, reject) => {
      fn(...args, (err, result) => {
        if (err) reject(err);
        else resolve(result);
      });
    });
  };
}

const readFileP = promisify(fs.readFile);
readFileP("file.txt", "utf8")
  .then((data) => console.log(data))
  .catch((err) => console.error(err));
``
`promisify` takes a callback-based function and returns a promise-based one. The callback must follow the error-first convention (`(err, result) => {}`).

### Using `util.promisify` (Node.js)

Node.js provides `util.promisify`:

```js
const { promisify } = require("util");
const fs = require("fs");

const readFileP = promisify(fs.readFile);
readFileP("file.txt", "utf8")
  .then((data) => console.log(data))
  .catch((err) => console.error(err));
``
Or with async/await:

```js
async function main() {
  try {
    const data = await readFileP("file.txt", "utf8");
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}
``
### Node.js Promise-Based APIs

Many Node.js APIs now have promise-based versions built in:

```js
const fs = require("fs").promises;
// or
const fs = require("fs/promises");

async function main() {
  const data = await fs.readFile("file.txt", "utf8");
  console.log(data);
}
``
No need to promisify. Use `fs/promises` directly.

### Promisifying Event-Based APIs

Some APIs are event-based, not callback-based. Promisifying them is different:

```js
function once(emitter, event) {
  return new Promise((resolve, reject) => {
    emitter.once(event, resolve);
    emitter.once("error", reject);
  });
}

const server = net.createServer();
await once(server, "listen");
``
Node.js provides `events.once` for this:

```js
const { once } = require("events");
await once(server, "listen");
``
### The Takeaway

Convert callbacks to promises with `promisify` (manual) or `util.promisify` (Node.js). Many Node.js APIs now have promise-based versions (`fs/promises`). Promisifying event-based APIs uses `new Promise` with `once` or `events.once`. Use async/await with the promisified versions for clean code.