Explication du contenu connexe de util.promisify

Le contenu de cet article est lié à util.promisify. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

util.promisify est un nouvel outil dans la version node.js 8.x. Il est utilisé pour convertir l'ancien rappel d'erreur en un objet Promise, facilitant ainsi la transformation des anciens projets.

Avant le lancement officiel de cet outil, il existait déjà de nombreux outils similaires dans le secteur privé, tels que es6-promisify, thenify et bluebird.promisify.

et bien d'autres excellents outils ont implémenté cette fonction, nous aidant à éviter d'avoir à réimplémenter divers codes à l'aide de Promise lorsque nous traitons d'anciens projets.

L'idée générale de​​mettre en œuvre l'outil

Tout d'abord, nous devons expliquer l'idée générale de​​mettre en œuvre cet outil, car il existe une convention pour les rappels asynchrones dans Node : Error first, c'est-à-dire qu'on dit que le premier paramètre de la fonction de rappel doit être un objet Error et que les paramètres restants sont les données correctes.

Après avoir connu cette règle, l'outil peut être facilement implémenté lorsque le premier paramètre correspond et a une valeur, le rejet est déclenché et la résolution est déclenchée dans les autres cas. Un exemple de code simple :

<.>

function util (func) {
  return (...arg) => new Promise((resolve, reject) => {
    func(...arg, (err, arg) => {
      if (err) reject(err)
      else resolve(arg)
    })
  })
}

L'appel de la fonction outil renvoie une fonction anonyme, et la fonction anonyme reçoit les paramètres de la fonction d'origine.

Une fois la fonction anonyme appelée, elle appelle la fonction réelle en fonction de ces paramètres et raccorde un rappel pour traiter le résultat.

Détecte que l'erreur a une valeur, déclenche le rejet et déclenche la résolution dans d'autres cas

resolve ne peut transmettre qu'un seul paramètre, il n'est donc pas nécessaire d'utiliser...arg dans le rappel pour obtenir tous les retours Valeurs

Utilisation conventionnelle

Prenons un exemple de la documentation officielle

const { promisify } = require('util')
const fs = require('fs')

const statAsync = promisify(fs.stat)

statAsync('.').then(stats => {
  // 拿到了正确的数据
}, err => {
  // 出现了异常
})

et comme c'est le cas

, nous pouvons utiliser Promise pour simplifier davantage le code : await

const { promisify } = require('util')
const fs = require('fs')

const statAsync = promisify(fs.stat)

// 假设在 async 函数中
try {
  const stats = await statAsync('.')
  // 拿到正确结果
} catch (e) {
  // 出现异常
}

l'utilisation n'est pas très différente des autres outils. Nous pouvons facilement convertir les rappels en

puis l'appliquer à de nouveaux projets. . Promise

Promesse personnalisée

Il existe certains scénarios dans lesquels promisify ne peut pas être utilisé directement pour la conversion. Il existe deux situations :

1. ne suit pas la convention de rappel d'erreur

2. Une fonction de rappel qui renvoie plusieurs paramètres

est la première. Si nous ne suivons pas notre convention, cela risque de provoquer une erreur de jugement ou de rejet. et pas de retour correct.

Quant au deuxième élément, c'est parce que Promise.resolve ne peut recevoir qu'un seul paramètre, et les paramètres supplémentaires seront ignorés.

Ainsi, afin d'obtenir des résultats corrects, nous devrons peut-être implémenter manuellement la fonction Promise correspondante, mais après l'avoir implémentée nous-mêmes, nous ne pouvons pas garantir que l'utilisateur n'appellera pas promisify pour votre fonction.

Ainsi, util.promisify fournit également une clé de type Symbole, util.promisify.custom.

Tous ceux qui connaissent le type Symbol doivent savoir qu'il s'agit d'une valeur unique. Ici, util.prosimify est utilisé pour spécifier le résultat Promise personnalisé. La méthode d'utilisation est la suivante :

const { promisify } = require('util')
// 比如我们有一个对象，提供了一个返回多个参数的回调版本的函数
const obj = {
  getData (callback) {
    callback(null, 'Niko', 18) // 返回两个参数，姓名和年龄
  }
}

// 这时使用promisify肯定是不行的
// 因为Promise.resolve只接收一个参数，所以我们只会得到 Niko

promisify(obj.getData)().then(console.log) // Niko

// 所以我们需要使用 promisify.custom 来自定义处理方式

obj.getData[promisify.custom] = async () => ({ name: 'Niko', age: 18 })

// 当然了，这是一个曲线救国的方式，无论如何 Promise 不会返回多个参数过来的
promisify(obj.getData)().then(console.log) // { name: 'Niko', age: 18 }

Concernant la raison pour laquelle Promise ne peut pas résoudre plusieurs valeurs, j'ai une idée audacieuse, une raison qui n'a pas été vérifiée et obligée d'expliquer : si elle peut résoudre plusieurs valeurs, comment demander à la fonction asynchrone de revenir (lisez simplement cette phrase pour le plaisir) , ne le prenez pas au sérieux)

Mais cela devrait vraiment être lié au retour, car Promise peut être appelée dans une chaîne Après avoir exécuté then dans chaque Promise, sa valeur de retour sera utilisée comme valeur de résolution d'une nouvelle Promise. object. Cela n'existe pas en JavaScript. La méthode renvoie plusieurs paramètres, donc même si la première Promise peut renvoyer plusieurs paramètres, ils seront perdus tant qu'ils sont traités par return

Lors de son utilisation, il est utilisé. est très simple d'ajouter promisify à la fonction qui peut être appelée promisify .custom peut être traité en conséquence.

Lors des appels de code suivants prometify, il sera jugé :

Si la fonction cible a l'attribut promisify.custom, son type sera jugé :

S'il ne s'agit pas d'une fonction exécutable , lancez une exception

S'il s'agit d'une fonction exécutable, sa fonction correspondante sera renvoyée directement

Si la fonction cible n'a pas l'attribut correspondant, la fonction de traitement correspondante sera générée selon le Erreur d'abord convention de rappel, puis renvoyée

Après avoir ajouté cet attribut personnalisé, vous n'avez plus à vous soucier de l'utilisateur qui appelle promisify pour votre fonction.

Et on peut vérifier que la fonction assignée à custom et l'adresse de fonction renvoyée par promisify sont au même endroit :

obj.getData[promisify.custom] = async () => ({ name: 'Niko', age: 18 })

// 上边的赋值为 async 函数也可以改为普通函数，只要保证这个普通函数会返回 Promise 实例即可
// 这两种方式与上边的 async 都是完全相等的

obj.getData[promisify.custom] = () => Promise.resolve({ name: 'Niko', age: 18 })
obj.getData[promisify.custom] = () => new Promise(resolve({ name: 'Niko', age: 18 }))

console.log(obj.getData[promisify.custom] === promisify(obj.getData)) // true

Certaines personnalisations intégrées traitement

Dans certains packages intégrés, vous pouvez également trouver des traces de promisify.custom Par exemple, le child_process.exec le plus couramment utilisé a un traitement promisify.custom intégré :

const { exec } = require('child_process')
const { promisify } = require('util')

console.log(typeof exec[promisify.custom]) // function

Parce que c'est comme l'exemple précédent Dans le plan pour sauver le pays à travers les courbes, l'approche officielle consiste à utiliser le nom du paramètre dans la signature de fonction comme clé et à stocker tous ses paramètres dans un objet Object pour return.Par exemple, la valeur de retour de child_process.exec contiendra des erreurs sauf error. Deux, stdout et stderr, l'un est la sortie correcte après l'exécution de la commande et l'autre est la sortie d'erreur après l'exécution de la commande :

promisify(exec)('ls').then(console.log)
// -> { stdout: 'XXX', stderr: '' }

Ou nous entrons délibérément des commandes erronées. Bien sûr, cela ne peut être fait que dans le module catch. Généralement, stderr sera une chaîne vide lorsque la commande est exécutée normalement :

promisify(exec)('lss').then(console.log, console.error)
// -> { ..., stdout: '', stderr: 'lss: command not found' }

包括像setTimeout、setImmediate也都实现了对应的promisify.custom。  
之前为了实现sleep的操作，还手动使用Promise封装了setTimeout：

const sleep = promisify(setTimeout)

console.log(new Date())

await sleep(1000)

console.log(new Date())

内置的 promisify 转换后函数

如果你的Node版本使用10.x以上的，还可以从很多内置的模块中找到类似.promises的子模块，这里边包含了该模块中常用的回调函数的Promise版本（都是async函数），无需再手动进行promisify转换了。

而且我本人觉得这是一个很好的指引方向，因为之前的工具实现，有的选择直接覆盖原有函数，有的则是在原有函数名后边增加Async进行区分，官方的这种在模块中单独引入一个子模块，在里边实现Promise版本的函数，其实这个在使用上是很方便的，就拿fs模块进行举例：

// 之前引入一些 fs 相关的 API 是这样做的
const { readFile, stat } = require('fs')

// 而现在可以很简单的改为
const { readFile, stat } = require('fs').promises
// 或者
const { promises: { readFile, stat } } = require('fs')

后边要做的就是将调用promisify相关的代码删掉即可，对于其他使用API的代码来讲，这个改动是无感知的。  
所以如果你的node版本够高的话，可以在使用内置模块之前先去翻看文档，有没有对应的promises支持，如果有实现的话，就可以直接使用。

promisify 的一些注意事项

1. 一定要符合Error first callback的约定

2. 不能返回多个参数

3. 注意进行转换的函数是否包含this的引用

前两个问题，使用前边提到的promisify.custom都可以解决掉。 

但是第三项可能会在某些情况下被我们所忽视，这并不是promisify独有的问题，就一个很简单的例子：

const obj = {
  name: 'Niko',
  getName () {
    return this.name
  }
}

obj.getName() // Niko

const func = obj.getName

func() // undefined

类似的，如果我们在进行Promise转换的时候，也是类似这样的操作，那么可能会导致生成后的函数this指向出现问题。  
修复这样的问题有两种途径：

1. 使用箭头函数，也是推荐的做法

2. 在调用promisify之前使用bind绑定对应的this

不过这样的问题也是建立在promisify转换后的函数被赋值给其他变量的情况下会发生。  
如果是类似这样的代码，那么完全不必担心this指向的问题：

const obj = {
  name: 'Niko',
  getName (callback) {
    callback(null, this.name)
  }
}

// 这样的操作是不需要担心 this 指向问题的
obj.XXX = promisify(obj.getName)

// 如果赋值给了其他变量，那么这里就需要注意 this 的指向了
const func = promisify(obj.getName) // 错误的 this

小结

个人认为Promise作为当代javaScript异步编程中最核心的一部分，了解如何将老旧代码转换为Promise是一件很有意思的事儿。 

而我去了解官方的这个工具，原因是在搜索Redis相关的Promise版本时看到了这个readme：This package is no longer maintained. node_redis now includes support for promises in core, so this is no longer needed.

然后跳到了node_redis里边的实现方案，里边提到了util.promisify，遂抓过来研究了一下，感觉还挺有意思，总结了下分享给大家。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!