Erläuterung verwandter Inhalte von util.promisify

Der Inhalt dieses Artikels bezieht sich auf util.promisify. Freunde in Not können darauf verweisen.

util.promisify ist ein neues Tool in der Version 8.x von node.js. Es wird verwendet, um den alten Error-First-Callback in ein Promise-Objekt umzuwandeln, was die Transformation alter Projekte erleichtert.

Vor der offiziellen Einführung dieses Tools gab es bereits viele ähnliche Tools im privaten Bereich, wie zum Beispiel es6-promisify, thenify und bluebird.promisify.

und viele andere hervorragende Tools haben diese Funktion implementiert und helfen uns, bei der Bearbeitung alter Projekte die erneute Implementierung verschiedener Codes mit Promise zu vermeiden.

Die allgemeine Idee der Implementierung des Tools

Zuerst müssen wir die allgemeine Idee der Implementierung dieses Tools erläutern, denn Es gibt eine Konvention für asynchrone Rückrufe in Node: Fehler zuerst, d. h. Es heißt, dass der erste Parameter in der Rückruffunktion ein Fehlerobjekt sein muss und die verbleibenden Parameter die richtigen Daten sind.

Nachdem Sie diese Regel kennen, kann das Tool einfach implementiert werden. Wenn der erste Parameter übereinstimmt und einen Wert hat, wird die Ablehnung ausgelöst und in anderen Fällen wird die Auflösung ausgelöst:

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

Rufen Sie die Tool-Funktion auf, um eine anonyme Funktion zurückzugeben, und die anonyme Funktion empfängt die Parameter der ursprünglichen Funktion.

Nachdem die anonyme Funktion aufgerufen wurde, ruft sie die reale Funktion basierend auf diesen Parametern auf und verbindet einen Rückruf zur Verarbeitung des Ergebnisses.

Erkennt, dass err einen Wert hat, löst eine Ablehnung aus und löst in anderen Fällen eine Auflösung aus

resolve kann nur einen Parameter übergeben, daher besteht keine Notwendigkeit, ...arg zu verwenden im Rückruf, um alle Rückgabewerte zu erhalten

Konventionelle Verwendung

Nehmen Sie ein Beispiel aus der offiziellen Dokumentation

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

const statAsync = promisify(fs.stat)

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

und da es können wir Promise verwenden, um den Code weiter zu vereinfachen: await

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

const statAsync = promisify(fs.stat)

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

Die Verwendung unterscheidet sich nicht wesentlich von der anderer Tools. Wir können Rückrufe problemlos in

umwandeln und sie dann auf neue Projekte anwenden. Promise

Customized Promise

Es gibt einige Szenarien, in denen Promise nicht direkt für die Konvertierung verwendet werden kann. Es gibt zwei Situationen:

1 folgt nicht der Fehler-ersten-Rückrufkonvention

2. Eine Rückruffunktion, die mehrere Parameter zurückgibt

ist die erste. Wenn wir unsere Konvention nicht befolgen, führt dies wahrscheinlich zu einer Fehleinschätzung der Ablehnung und kein richtiges Feedback.

Der zweite Punkt liegt daran, dass Promise.resolve nur einen Parameter empfangen kann und die zusätzlichen Parameter ignoriert werden.

Um korrekte Ergebnisse zu erzielen, müssen wir möglicherweise die entsprechende Promise-Funktion manuell implementieren. Nachdem wir sie jedoch selbst implementiert haben, können wir nicht sicherstellen, dass der Benutzer nicht promisify für Ihre Funktion aufruft.

Deshalb stellt util.promisify auch einen Symboltypschlüssel bereit, util.promisify.custom. Jeder, der den

Symboltyp kennt, sollte wissen, dass es sich um einen eindeutigen Wert handelt. Hier wird util.prosimify verwendet, um das benutzerdefinierte Promise-Ergebnis anzugeben:

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 }

Über das Warum Versprechen kann nicht mehrere Werte auflösen? Ich habe eine mutige Idee, einen Grund, der nicht überprüft und erklärt werden muss: Wenn es mehrere Werte auflösen kann, wie fordert man die asynchrone Funktion auf, zurückzukehren (lesen Sie einfach diesen Satz zum Spaß, Nicht im Ernst)

Aber es sollte sich auf die Rückgabe beziehen, da Promise in einer Kette aufgerufen werden kann. Nach der Ausführung wird sein Rückgabewert als Wert eines neuen Promise-Objekts verwendet Es gibt keine Möglichkeit, in JavaScript mehrere Parameter zurückzugeben. Selbst wenn das erste Versprechen mehrere Parameter zurückgeben kann, gehen diese verloren, solange sie durch Rückgabe verarbeitet werden.

Bei der Verwendung ist es sehr einfach, Versprechen hinzuzufügen .custom für die Funktion, die als promisify bezeichnet werden kann. Gehen Sie einfach entsprechend vor.

Wenn nachfolgende Codeaufrufe vielversprechend sind, wird dies beurteilt:

Wenn die Zielfunktion das Attribut promisify.custom hat, wird ihr Typ beurteilt:

Wenn es sich nicht um eine ausführbare Funktion handelt , Ausnahme auslösen

Wenn es sich um eine ausführbare Funktion handelt, wird die entsprechende Funktion direkt zurückgegeben

Wenn die Zielfunktion nicht über das entsprechende Attribut verfügt, wird die entsprechende Verarbeitungsfunktion gemäß generiert Fehler zuerst bei Rückrufkonvention und dann zurückgegeben

Nachdem Sie dieses benutzerdefinierte Attribut hinzugefügt haben, müssen Sie sich keine Sorgen mehr machen, dass der Benutzer „promisify“ für Ihre Funktion aufruft.

Und es kann überprüft werden, dass sich die der benutzerdefinierten Funktion zugewiesene Funktion und die von promisify zurückgegebene Funktionsadresse an derselben Stelle befinden:

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

Einige integrierte benutzerdefinierte Verarbeitung

In einigen integrierten Paketen finden Sie auch Spuren von promisify.custom. Beispielsweise verfügt die am häufigsten verwendete child_process.exec über eine integrierte promisify.custom-Verarbeitung:

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

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

Denn wie im vorherigen Beispiel erwähnt Um das Land zu speichern, besteht die offizielle Methode darin, den Parameternamen in der Funktionssignatur als Schlüssel zu verwenden und alle seine Parameter zur Rückgabe in einem Objektobjekt zu speichern von child_process.exec enthält zwei stdout, außer error und stderr, eine ist die korrekte Ausgabe nach der Ausführung des Befehls und die andere ist die Fehlerausgabe nach der Ausführung des Befehls:

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

Oder wir geben absichtlich ein Einige falsche Befehle können natürlich nur unter dem Catch-Modul erfasst werden. Wenn ein normaler Befehl ausgeführt wird, ist stderr eine leere Zeichenfolge:

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，遂抓过来研究了一下，感觉还挺有意思，总结了下分享给大家。

Das obige ist der detaillierte Inhalt vonErläuterung verwandter Inhalte von util.promisify. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!