Promise.promisifyAll(
    Object target,[Object 
        suffix: String="Async",
        multiArgs: boolean=false,
        filter: boolean function(String name,function func, Object target, boolean passesDefaultFilter),promisifier:function(function originalFunction,function defaultPromisifier) options])-> Object

Promisifica el objeto completo revisando las propiedades del objeto y creando un equivalente asíncrono de cada función en el objeto y su cadena de prototipos. El nombre del método prometido será el nombre del método original con el sufijo suffix (por defecto es "Async"). Todas las propiedades de clase del objeto (que es el caso de la exportación principal de muchos módulos) también se promisifican, tanto métodos estáticos como de instancia. La propiedad de clase es una propiedad con un valor de función que no está vacío .prototype objeto. Devuelve el objeto de entrada.

Tenga en cuenta que los métodos originales en el objeto no se sobrescriben, pero se crean nuevos métodos con el Async-sufijo. Por ejemplo, si tu promisifyAll el node.js fs uso de objetos fs.statAsync llamar al prometido stat método.

Ejemplo:

Promise.promisifyAll(require("redis"));//Later on, all redis client instances have promise returning functions:

redisClient.hexistsAsync("myhash","field").then(function(v)).catch(function(e));

También funciona en singletons o instancias específicas:

var fs = Promise.promisifyAll(require("fs"));

fs.readFileAsync("myfile.js","utf8").then(function(contents)
    console.log(contents);).catch(function(e)
    console.error(e.stack););

Consulte promisificación para ver más ejemplos.

Toda la cadena de prototipos del objeto se promete sobre el objeto. Solo se consideran enumerables. Si el objeto ya tiene una versión prometida del método, se omitirá. Se supone que los métodos de destino cumplen con la convención de devolución de llamada de node.js de aceptar una devolución de llamada como último argumento y llamar a esa devolución de llamada con error como primer argumento y valor de éxito en el segundo argumento. Si el método de nodo llama a su devolución de llamada con varios valores de éxito, el valor de cumplimiento será una matriz de ellos.

Si el nombre de un método ya tiene un "Async"-sufijo, se lanzará una excepción.

Opción: sufijo

Opcionalmente, puede definir un sufijo personalizado a través del objeto de opciones:

var fs = Promise.promisifyAll(require("fs"),suffix:"MySuffix");
fs.readFileMySuffix(...).then(...);

Todas las limitaciones anteriores se aplican a las suficies personalizadas:

  • Elija el sufijo con cuidado, no debe chocar con nada
  • PascalCase el sufijo
  • El sufijo debe ser un identificador JavaScript válido con letras ASCII.
  • Utilice siempre el mismo sufijo en todas partes de su aplicación, podría crear un contenedor para facilitar esto:
module.exports=functionmyPromisifyAll(target)return Promise.promisifyAll(target,suffix:"MySuffix");;

Opción: multiArgs

Configuración multiArgs para true significa que la promesa resultante siempre se cumplirá con una matriz de los valores de éxito de la devolución de llamada. Esto es necesario porque las promesas solo admiten un único valor de éxito, mientras que algunas API de devolución de llamada tienen varios valores de éxito. El valor predeterminado es ignorar todos menos el primer valor de éxito de una función de devolución de llamada.

Si un módulo tiene devoluciones de llamada de múltiples argumentos como excepción en lugar de la regla, puede filtrar los métodos de múltiples argumentos en la primera operación y luego promisificar el resto del módulo en la segunda:

Promise.promisifyAll(something,filter:function(name)return name ==="theMultiArgMethodIwant";,
    multiArgs:true);// Rest of the methods
Promise.promisifyAll(something);

Opción: filtro

Opcionalmente, puede definir un filtro personalizado a través del objeto de opciones:

Promise.promisifyAll(...,filter:function(name, func, target, passesDefaultFilter)// name = the property name to be promisified without suffix// func = the function// target = the target object where the promisified func will be put with name + suffix// passesDefaultFilter = whether the default filter would be passed// return boolean (return value is coerced, so not returning anything is same as returning false)return passesDefaultFilter &&...)

La función de filtro predeterminada ignorará las propiedades que comienzan con un subrayado inicial, las propiedades que no son identificadores de JavaScript válidos y las funciones de constructor (función que tiene propiedades enumerables en su .prototype).

Opción: promisificador

Opcionalmente, puede definir un promisificador personalizado, por lo que podría promisificarTodas, por ejemplo, las API de Chrome utilizadas en las extensiones de Chrome.

El promisorio obtiene una referencia al método original y debería devolver una función que devuelva una promesa.

functionDOMPromisifier(originalMethod)// return a functionreturnfunctionpromisified()var args =[].slice.call(arguments);// Needed so that the original method can be called with the correct receivervar self =this;// which returns a promisereturnnewPromise(function(resolve, reject)
            args.push(resolve, reject);originalMethod.apply(self, args););;// Promisify e.g. chrome.browserAction
Promise.promisifyAll(chrome.browserAction,promisifier: DOMPromisifier);// Later
chrome.browserAction.getTitleAsync(tabId:1).then(function(result));

Combinatorio filter con promisifier para que el módulo restler promisifique el emisor de eventos:

var Promise =require("bluebird");var restler =require("restler");var methodNamesToPromisify ="get post put del head patch json postJson putJson".split(" ");functionEventEmitterPromisifier(originalMethod)// return a functionreturnfunctionpromisified()var args =[].slice.call(arguments);// Needed so that the original method can be called with the correct receivervar self =this;// which returns a promisereturnnewPromise(function(resolve, reject)// We call the originalMethod here because if it throws,// it will reject the returned promise with the thrown errorvar emitter =originalMethod.apply(self, args);

            emitter
                .on("success",function(data, response)resolve([data, response]);).on("fail",function(data, response)// Erroneous response like 400resolve([data, response]);).on("error",function(err)reject(err);).on("abort",function()reject(newPromise.CancellationError());).on("timeout",function()reject(newPromise.TimeoutError());););;;

Promise.promisifyAll(restler,filter:function(name)return methodNamesToPromisify.indexOf(name)>-1;,
    promisifier: EventEmitterPromisifier
);// ...// Later in some other filevar restler =require("restler");
restler.getAsync("http://...",...,).spread(function(data, response))

Utilizando defaultPromisifier parámetro para agregar mejoras además de la promisificación normal del nodo:

var fs = Promise.promisifyAll(require("fs"),promisifier:function(originalFunction, defaultPromisifer)var promisified =defaultPromisifier(originalFunction);returnfunction()// Enhance normal promisification by supporting promises as// argumentsvar args =[].slice.call(arguments);var self =this;return Promise.all(args).then(function(awaitedArgs)returnpromisified.apply(self, awaitedArgs););;);// All promisified fs functions now await their arguments if they are promisesvar version = fs.readFileAsync("package.json","utf8").then(JSON.parse).get("version");
fs.writeFileAsync("the-version.txt", version,"utf8");

Prometiendo múltiples clases de una sola vez

Puede prometer varias clases de una sola vez construyendo una matriz a partir de las clases y pasándola a promisifyAll:

var Pool =require("mysql/lib/Pool");var Connection =require("mysql/lib/Connection");
Promise.promisifyAll([Pool, Connection]);

Esto funciona porque la matriz actúa como un “módulo” donde los índices son las propiedades del “módulo” para las clases.