Lecture du code source : promiseify

Lecture du code source : promiseify

Introduction

En JavaScript, les fonctions de rappel sont un moyen courant de gérer les opérations asynchrones. Cependant, l’utilisation de fonctions de rappel peut conduire à un code trop profondément imbriqué pour être compris et maintenu. PromiseifyEn résolvant ce problème, il peut convertir les fonctions asynchrones basées sur le rappel en fonctions renvoyées Promise, permettant ainsi aux développeurs de gérer plus facilement les opérations asynchrones et Promised'écrire du code à l'aide d'appels en chaîne, en utilisant un code plus clair et plus concis pour gérer les opérations asynchrones.

PromiseifyL'utilisation est très simple, il suffit d'appeler sa fonction et de passer la fonction asynchrone qui doit être convertie en paramètre. PromiseifyRenvoie une nouvelle fonction, cette nouvelle fonction renvoie un Promiseobjet. Nous pouvons effectuer des opérations asynchrones originales en appelant cette fonction renvoyée et Promisegérer les résultats et les erreurs à l'aide d'appels chaînés.

promiseifyL'utilisation de base est la suivante :

1. Importez promiseifyle module (CommonJS comme exemple) :

const promiseify = require('promiseify');

2. Transmettez la fonction qui doit être convertie en promiseifyfonction et obtenez la Promiseversion renvoyée de la fonction :

const promiseFunc = promiseify(callbackFunc);

3. Utilisez la fonction renvoyée promiseFuncpour les opérations asynchrones :

promiseFunc(args)
  .then((result) => {
    
    
    // 处理成功的结果
  })
  .catch((error) => {
    
    
    // 处理错误
  });

promiseifyLe principe de fonctionnement consiste à envelopper la fonction de rappel d'origine dans une nouvelle Promiseet à déterminer Promisel'état en fonction du résultat de l'exécution de la fonction de rappel. Si la fonction de rappel s'exécute avec succès, Promiseelle sera analysée comme un statut de réussite et la valeur du résultat sera transmise ; si la fonction de rappel échoue, Promiseelle sera rejetée et un objet d'erreur sera transmis.

Interprétation du code source

'use strict';

Premièrement, le code utilise le mode strict ( 'use strict') pour garantir la rigueur et la sécurité du code.

Ensuite, une fonction est définie promiseifyqui accepte deux paramètres : methodet ctx(facultatif). methodLe paramètre est la fonction qui doit être convertie et ctxle paramètre est le contexte ( ) qui sert de fonction this.

/**
 * promiseify
 * @param {function} method function
 * @param {object} ctx optional ctx for method
 */
function promiseify(method, ctx) {
    
    

  // check first
  if (typeof method !== 'function') {
    
    
    throw new TypeError(String(method) + ' is not a function');
  }

  return function() {
    
    

    // runtime args
    var args = [].slice.call(arguments);

    // runtime this
    ctx = ctx || this;

    return new Promise(function(resolve, reject) {
    
    

      args.push(function(err) {
    
    
        if (err) {
    
    
          return reject(err);
        }
        var arg = [].slice.call(arguments);
        if (arg.length === 2) {
    
    
          resolve.call(this, arg[1]);
        } else {
    
    
          resolve.call(this, arg.slice(1));
        }
      });

      try {
    
    
        method.apply(ctx, args);
      } catch (err) {
    
    
        reject(err);
      }
    });
  };
}

1. Le code effectue d'abord une vérification des paramètres pour s'assurer que le paramètre de la méthode est une fonction. S'il ne s'agit pas d'une fonction, une erreur de type est générée.
2. Ensuite, une nouvelle fonction est renvoyée, qui devient la Promiseversion renvoyée de la fonction.
3. Dans la nouvelle fonction, récupérez d’abord les paramètres d’exécution ( arguments) et convertissez-les en tableau.
4. thisEnsuite, définissez le contexte d'exécution de la fonction en fonction du paramètre de contexte transmis ou du contexte par défaut ( ).
5. Ensuite, créez-en une nouvelle Promiseet Promisetransmettez une nouvelle fonction de rappel en tant que paramètre dans le constructeur. Cette fonction de rappel accepte deux paramètres : resolveet reject.
6. Dans la fonction de rappel, vérifiez d'abord s'il existe un paramètre d'erreur ( err). S'il y a une erreur, rejectla méthode sera Promiserejetée et l'objet d'erreur sera transmis.
7. S'il n'y a aucune erreur, utilisez [].slice.call(arguments)Convertir les paramètres de la fonction de rappel en tableau ( arg).
8. resolveEnsuite, les paramètres transmis lors de l'appel sont déterminés en fonction de la longueur des paramètres . Si la longueur du paramètre est 2, cela signifie qu'il y a un paramètre d'erreur et un paramètre de résultat. A ce moment, resolvela méthode est appelée et le paramètre de résultat ( arg[1]) est passé ; sinon, resolvela méthode est appelée et le tableau de paramètres de résultat ( arg.slice(1)) est passé.
9. Enfin, try-catchla fonction asynchrone d'origine ( method.apply(ctx, args)) est exécutée dans le bloc, et si une erreur se produit, la rejectméthode consommatrice la Promiserejettera, transmettant l'objet d'erreur.

/**
 * promiseify all
 * @param  {object} o the target object
 * @return {object}   same to target object
 *
 * @example
 *   var fs = promiseify.all(require('fs'));
 *   fs.readFileAsync('file.txt', 'utf8')
 *     .then(function(s){ console.log(s); });
 *
 *   var Connection = require('mysql/lib/Connection');
 *   promiseify.all(Connection.prototype);
 *   // conn.connectAsync / conn.queryAsync / conn.endAsync available now
 */
promiseify.all = function(o) {
    
    
  Object.keys(o)
    .filter(function(m) {
    
    
      return typeof o[m] === 'function';
    })
    .forEach(function(m) {
    
    
      o[m + 'Async'] = promiseify(o[m]);
    });
  return o;
};

Cette partie est une promiseify.allfonction qui prend un objet comme paramètre et parcourt toutes les propriétés de cet objet. Pour les attributs dont la valeur est une fonction, convertissez-la en Promiseune version de la fonction et ajoutez la nouvelle fonction à l'objet avec le nom de fonction d'origine plus Asyncun suffixe.

Object.defineProperty(promiseify, "__esModule", {
    
     value: true });
promiseify.default = promiseify;
module.exports = promiseify;

Ce code est principalement utilisé pour exporter promiseifyla fonction sous forme de module. Tout d’abord, utilisez Object.definePropertyla méthode pour promiseifyajouter une "__esModule"propriété nommée à l’objet avec une valeur de true. Ceci indique que le module est un module ES. Ensuite, définissez promiseify.defaultla propriété sur promiseifyla fonction elle-même. De cette façon, lorsque vous utilisez importl'importation de syntaxe, vous pouvez obtenir promiseifyla fonction directement. Enfin, utilisez module.exportsexport promiseifyla fonction en tant que module. requireDe cette façon, la fonction peut être obtenue en utilisant la syntaxe import promiseify.

développer

En JavaScript, un objet de type tableau fait référence à un objet qui possède les caractéristiques d'un tableau, mais qui n'est pas un véritable tableau. Ils ont une propriété de longueur de type tableau et la possibilité d'accéder aux éléments par index. Cependant, les objets de type tableau n'ont pas les méthodes et propriétés prototypes des tableaux.

Les objets courants de type tableau incluent :

1. argumentsObjet : un objet créé automatiquement dans une fonction pour stocker les paramètres transmis à la fonction.
2. Liste d'éléments DOM (NodeList) : collection d'objets renvoyés par l'interrogation d'éléments DOM, tels que querySelectorAllles résultats obtenus via des méthodes.
3. Chaîne : les caractères d’une chaîne sont accessibles par index.
4. Objets de type tableau : certains objets peuvent être conçus pour ressembler à des tableaux, par exemple en implémentant une interface itérateur de type tableau.

Il existe plusieurs façons de convertir un objet de type tableau en un véritable tableau :

1. UtilisationArray.from() : Array.from()La méthode peut convertir un objet de type tableau ou un objet itérable en un nouveau tableau. Par exemple:var array = Array.from(arrayLike);
2. Utilisez l'opérateur de propagation (Spread Operator) : L'opérateur de propagation (...) peut répartir un objet de type tableau dans un nouveau tableau. Par exemple:var array = [...arrayLike];
3. Utilisation : Vous pouvez convertir un objet de type tableau en tableau Array.prototype.slice.call()en appelant la méthode et en passant un objet de type tableau comme contexte. Array.prototype.slicePar exemple:var array = Array.prototype.slice.call(arrayLike);
4. Utilisation Array.prototype.concat(): Vous pouvez convertir un objet de type tableau en tableau en appelant Array.prototype.concatla méthode et en passant un objet de type tableau en tant que paramètre. Par exemple:var array = Array.prototype.concat.call([], arrayLike);

Il convient de noter que les méthodes ci-dessus créent toutes un nouveau tableau plutôt que de modifier directement l'objet de type tableau d'origine.