J'ai déposé ce problème avec TypeStrong
https://github.com/TypeStrong/ts-node/issues/494
il y a une vidéo qui montre le problème
voici le code incriminé :
const async = require('async');
async.series({
one: async function(){
let x = await 1;
return x;
},
two: async function(){
let x = await 2;
return x;
}
},
function(err, results){
if(err){
throw err;
}
console.log('results =>', results);
});
qui/qu'est-ce qui est à blâmer ? Merci
semble être un problème TypeScript
Salut @ORESoftware , merci pour la question !
Il s'agit d'un problème de transpilation, car nous ne pouvons détecter que les fonctions natives async
. Si vous transpilez votre code, vous devez envelopper vos fonctions async
avec asyncify
. Voir les AsyncFunction
docs pour plus d'informations.
@hargasinski c'est un problème - oui je vois qu'il est transpilé à ceci :
#!/usr/bin/env node
'use strict';
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var suman = require('suman');
var Test = suman.init(module, {
forceParallel: true
}).Test;
var async = require('async');
var count = 0;
async.series({
a: function XXXXX() {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, 300];
case 1:
_a.sent();
return [2, 5];
}
});
});
}
}, function (err, results) {
if (err) {
throw err;
}
console.log('results => ', results);
});
pouvez-vous s'il vous plaît utiliser Function.length
? alias XXXXX.length
si la longueur est
0 => supposer async/attendre, ou des promesses
1 => c'est un rappel, passer un rappel
2 => lancer une erreur
Voir le dernier paragraphe : http://caolan.github.io/async/global.html
C'est un problème de transpileur. Si la fonction générée avait fn[Symbol.toStringTag] = 'AsyncFunction'
cela fonctionnerait, mais cela suppose des symboles non transpilés. La plupart des transpileurs ne laissent pas les symboles tels quels.
Vous devrez envelopper les fonctions async
dans asyncify()
si vous transpilez.