javascript - Node.js'de TypeScript async await kullanımı

Aşağıdaki 4 şeyi aynı anda yapmayı imkansız buldum:

1. Node.js'te Yazma
2. TypeScript ile yazmak
3. async await kullanımı
4. Kolayca hata ayıklama

Açıklama:

TypeScript ile yazılmış bir Node.js projem var ve bu projede async await kullanmaya çalışıyorum.

Şimdi sorun şu ki, eğer ES6'ya dönüştürürsem, import anahtar kelimesi burada tartışıldığı gibi "beklenmeyen token import" hatası üretiyor: ES6 import ve export Node.js'te desteklenmiyor, oysa ES5'e dönüştürürsem, async await okunaksız bir koda dönüşüyor:

Bu :

///<reference path="../typings/modules/bluebird/index.d.ts" />
///<reference path="../typings/modules/mongodb/index.d.ts" />

import * as Promise from 'bluebird';
import { MongoClient, Db } from 'mongodb';
import {Campaign} from "../classes/Campaign";

export async function getCampaigns(): Campaign[] {
    try{
        var db = await connect();
        var campaigns: Campaign[] =  await db.collection("campaigns").find().toArray();
        return campaigns;
    }
    catch (err){
        console.log(err);
    }
}

async function connect(): Promise<Db> {
    return await MongoClient.connect("mongodb://localhost:27017/db");
}

bu hale gelir:

"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;
    return { next: verb(0), "throw": verb(1), "return": verb(2) };
    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 };
    }
};

    ///<reference path="../typings/modules/bluebird/index.d.ts" />
    ///<reference path="../typings/modules/mongodb/index.d.ts" />
    var Promise = require("bluebird");
    var mongodb_1 = require("mongodb");
    function getCampaigns() {
        return __awaiter(this, void 0, void 0, function () {
            var db, campaigns, err_1;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        _a.trys.push([0, 3, , 4]);
                        return [4 /*yield*/, connect()];
                    case 1:
                        db = _a.sent();
                        return [4 /*yield*/, db.collection("campaigns").find().toArray()];
                    case 2:
                        campaigns = _a.sent();
                        return [2 /*return*/, campaigns];
                    case 3:
                        err_1 = _a.sent();
                        console.log(err_1);
                        return [3 /*break*/, 4];
                    case 4: return [2 /*return*/];
                }
            });
        });
    }
    exports.getCampaigns = getCampaigns;
    function connect() {
        return __awaiter(this, void 0, Promise, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, mongodb_1.MongoClient.connect("mongodb://localhost:27017/db")];
                    case 1: return [2 /*return*/, _a.sent()];
                }
            });
        });
    }

Bu paradoksu nasıl çözebilirim?

Cevap #1

Eğer ES6'ya transpil edersem, import anahtar kelimesi "beklenmeyen import tokeni" hatası üretir

Aslında iki çözüm var. İster birini ister her ikisinin kombinasyonunu seçin:

• ES6 importları yerine her zaman import/require kullanın
• --module commonjs belirtin

Hedefi ve ES6'yı koru ve eğlen :)