文件从头开始读函数_如何从头开始编写自己的Promisify函数

文件从头开始读函数

介绍 (Introduction)

In this article, you will learn how to write your own promisify function from scratch.

在本文中，您将学习如何从头开始编写自己的promisify函数。

Promisification helps in dealing with callback-based APIs while keeping code consistent with promises.

Promisification有助于处理基于回调的API，同时使代码与Promise保持一致。

We could just wrap any function with new Promise() and not worry about it at all. But doing that when we have many functions would be redundant.

我们可以用new Promise()包装任何函数，而完全不用担心。但是，当我们有许多功能时，这样做将是多余的。

If you understand promises and callbacks, then learning how to write promisify functions should be easy. So let's get started.

如果您了解承诺和回调，那么学习如何编写承诺函数应该很容易。因此，让我们开始吧。

但是，您是否曾经想知道混杂如何起作用？ (But have you ever wondered how promisify works? )

The important thing is not to stop questioning. Curiosity has its own reason for existence.

重要的是不要停止质疑。好奇心有其存在的原因。

The important thing is not to stop questioning. Curiosity has its own reason for existence.

重要的是不要停止质疑。好奇心有其存在的原因。

Promises were introduced in the ECMA-262 Standard, 6th Edition (ES6) that was published in June 2015.

在2015年6月发布的ECMA-262标准第6版 (ES6)中引入了承诺。

It was quite an improvement over callbacks, as we all know how unreadable "callback hell" can be :)

与回调相比，这是一个很大的进步，因为我们都知道“回调地狱”是多么难以理解：)

As a Node.js developer, you should know what a promise is and how it works internally, which will also help you in JS interviews. Feel free to review them quickly before reading on.

作为Node.js开发人员，您应该知道什么是诺言以及它如何在内部工作，这也将在JS面试中为您提供帮助。在继续阅读之前，请随时快速阅读它们。

为什么我们需要将回调转换为Promise？ (Why do we need to convert callbacks to promises?)

With callbacks, if you want to do something sequentially you will have to specify an err argument in each callback, which is redundant. In promises or async-await, you can just add a .catch method or block which will catch any errors that occurred in the promise chain

对于回调，如果要顺序执行某项操作，则必须在每个回调中指定一个err参数，这是多余的。在promise或async-await中，您只需添加.catch方法或块即可捕获promise链中发生的任何错误。
With callbacks, you have no control over when it's called, under what context, or how many times it's being called, which can lead to memory leaks.使用回调，您无法控制何时调用它，在什么上下文中或调用多少次，否则可能导致内存泄漏。
Using promises, we control these factors (especially error handling) so the code is more readable and maintainable.使用promise，我们可以控制这些因素(尤其是错误处理)，因此代码更具可读性和可维护性。

如何使基于回调的函数返回承诺 (How to make callback-based functions return a promise)

There are two ways to do it:

有两种方法可以做到这一点：

Wrap the function in another function which returns a promise. It then resolves or rejects based on callback arguments.将函数包装在另一个返回诺言的函数中。然后，它根据回调参数解析或拒绝。
Promisification — We create a util/helper function promisify which will transform all error first callback-based APIs.

Promisification —我们创建了一个util / helper函数promisify ，它将转换所有基于错误的基于回调的API。

Example: there’s a callback-based API which provides the sum of two numbers. We want to promisify it so it returns a thenable promise.

示例：有一个基于回调的API，该API提供两个数字的总和。我们要承诺它，以便它返回可thenable承诺。

const getSumAsync = (num1, num2, callback) => {if (!num1 || !num2) {return callback(new Error("Missing arguments"), null);}return callback(null, num1 + num2);
}
getSumAsync(1, 1, (err, result) => {if (err){doSomethingWithError(err)}else {console.log(result) // 2}
})

兑现诺言 (Wrap into a promise)

As you can see, getSumPromise delegates all the work to the original function getSumAsync, providing its own callback that translates to promise resolve/reject.

如您所见， getSumPromise将所有工作委托给原始函数getSumAsync ，提供其自己的回调，以转换为promise resolve/reject 。

承诺 (Promisify)

When we need to promisify many functions we can create a helper function promisify.

当我们需要promisify许多功能时，我们可以创建一个helper function promisify 。

什么是Promisification？ (What is Promisification?)

Promisification means transformation. It’s a conversion of a function that accepts a callback into a function returning a promise.

承诺意味着转变。这是将接受回调的函数转换为返回promise的函数的转换。

Using Node.js's util.promisify():

使用Node.js的util.promisify() ：

const { promisify } = require('util')
const getSumPromise = promisify(getSumAsync) // step 1
getSumPromise(1, 1) // step 2
.then(result => {console.log(result)
})
.catch(err =>{doSomethingWithError(err);
})

So it looks like a magic function which is transforming getSumAsync into getSumPromise which has .then and .catch methods

所以它看起来像一个神奇的功能它正在改变getSumAsync到getSumPromise已.then和.catch方法

让我们编写我们自己的promisify函数： (Let’s write our own promisify function:)

If you look at step 1 in the above code, the promisify function accepts a function as an argument, so the first thing we have to do write a function that can do the same:

如果您看上面代码中的步骤1 ， promisify函数promisify函数接受为参数，因此我们首先要做的是编写一个可以执行相同操作的函数：

const getSumPromise = myPromisify(getSumAsync)
const myPromisify = (fn) => {}

After that, getSumPromise(1, 1) is a function call. This means that our promisify should return another function which can be called with the same arguments of the original function:

之后， getSumPromise(1, 1)是一个函数调用。这意味着我们的promisify应该返回另一个函数，该函数可以使用与原始函数相同的参数来调用：

const myPromisify = (fn) => {return (...args) => {}
}

In the above code you can see we are spreading arguments because we don’t know how many arguments the original function has. args will be an array containing all the arguments.

在上面的代码中，您可以看到我们正在散布参数，因为我们不知道原始函数有多少个参数。 args将是一个包含所有参数的数组。

When you call getSumPromise(1, 1) you’re actually calling (...args)=> {}. In the implementation above it returns a promise. That’s why you’re able to use getSumPromise(1, 1).then(..).catch(..).

调用getSumPromise(1, 1) ，实际上是在调用(...args)=> {} 。在上面的实现中，它返回一个promise。这就是为什么您可以使用getSumPromise(1, 1).then(..).catch(..) 。

I hope you’ve gotten the hint that the wrapper function (...args) => {} should return a promise.

希望您得到了包装函数(...args) => {}应该返回promise的提示。

兑现承诺 (Return a promise)

const myPromisify = (fn) => {return (...args) => {return new Promise((resolve, reject) => {})}
}

Now the tricky part is how to decide when to resolve or reject a promise.Actually, that will be decided by the original getSumAsync function implementation – it will call the original callback function and we just need to define it. Then based on err and result we will reject or resolve the promise.

现在最棘手的部分是如何决定何时resolve or reject承诺。实际上，这将由原始的getSumAsync函数实现决定–它会调用原始的回调函数，而我们只需要定义它即可。然后根据err并result我们将reject或resolve的承诺。

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

Our args[] only consists of arguments passed by getSumPromise(1, 1) except the callback function. So you need to add customCallback(err, result) to the args[]which the original function getSumAsync will call accordingly as we are tracking the result in customCallback.

我们的args[]仅包含getSumPromise(1, 1)传递的参数getSumPromise(1, 1)回调函数除外getSumPromise(1, 1) 。因此，您需要在args[]添加customCallback(err, result) ，当我们在customCallback中跟踪结果时，原始函数getSumAsync将相应地调用customCallback 。

将customCallback推送到args [] (Push customCallback to args[])

const myPromisify = (fn) => {return (...args) => {return new Promise((resolve, reject) => {function customCallback(err, result) {if (err) {reject(err)}else {resolve(result);}}args.push(customCallback)fn.call(this, ...args)})}
}

As you can see, we have added fn.call(this, args), which will call the original function under the same context with the arguments getSumAsync(1, 1, customCallback). Then our promisify function should be able to resolve/reject accordingly.

如您所见，我们添加了fn.call(this, args) ，它将在相同的上下文中使用参数getSumAsync(1, 1, customCallback)调用原始函数。然后，我们的承诺功能应能够相应地resolve/reject 。

The above implementation will work when the original function expects a callback with two arguments, (err, result). That’s what we encounter most often. Then our custom callback is in exactly the right format and promisify works great for such a case.

当原始函数需要一个带有两个参数(err, result)的回调时，上述实现将起作用。这就是我们最常遇到的问题。然后，我们的自定义回调将采用完全正确的格式，并且promisify在这种情况下非常promisify 。

But what if the original fn expects a callback with more arguments like callback(err, result1, result2, ...)?

但是，如果原始的 fn 期望回调包含更多的参数，例如 callback(err, result1, result2, ...) 吗？

In order to make it compatible with that, we need to modify our myPromisify function which will be an advanced version.

为了使其兼容，我们需要修改myPromisify函数，它将是一个高级版本。

const myPromisify = (fn) => {return (...args) => {return new Promise((resolve, reject) => {function customCallback(err, ...results) {if (err) {return reject(err)}return resolve(results.length === 1 ? results[0] : results) }args.push(customCallback)fn.call(this, ...args)})}
}

Example:

例：

const getSumAsync = (num1, num2, callback) => {if (!num1 || !num2) {return callback(new Error("Missing dependencies"), null);}const sum = num1 + num2;const message = `Sum is ${sum}`return callback(null, sum, message);
}
const getSumPromise = myPromisify(getSumAsync)
getSumPromise(2, 3).then(arrayOfResults) // [6, 'Sum is 6']

That’s all! Thank you for making it this far!

就这样！谢谢您的成功！

I hope you’re able to grasp the concept. Try to re-read it again. It’s a bit of code to wrap your head around, but not too complex. Let me know if it was helpful