nodejs(JavaScript)设计模式以避免异步混乱

Question

我在与JS的大型项目上工作有点新，我觉得几乎所有内容都很难保持代码清洁。
我正在创造很多承诺，几乎将每个功能都称为异步，并且几乎在每一行上都在等待，我觉得这不是管理它的正确方法。
示例：

    var mysql = require('mysql');
module.exports = class MyClass {
    constructor() {
    }
    async init(){
        await this._initDbConnection();
    }
    _initDbConnection(){
        return new Promise(function(resolve, reject){
            this.db = mysql.createConnection({
                ...
            });
            this.db.connect(function(err) {
                ...    
            });    
        });
    }
    tableExists(tableName){
        return new Promise...            
    }
    createTable(tableName){
        return new Promise...
    }
    async save(data){
        try{
            if( ! (await this.tableExists()) ){
                await this.createTable();
            }
            return new Promise(function(resolve, reject){
                this.db.query(sql, function (err, result) {
                    ...                    
                });
            });
        }
        catch(e){
        }
    }
};
const myclass = new MyClass();
await myclass.init();
await myclass.save();
await 
await 
await !

每个查询或执行异步的任何内容相同。
这是一个非常丑陋的解决方案。
我的意思是，如果我需要从数据库中使用的东西，我想在第一行中连接到DB，然后在第二行中执行查询，然后在第三行上处理结果。使用JS来执行此操作，我需要创建大量回调或在每行等待？？？

Answer 1

对于非常具体的情况初始化异步资源的您可以使用几种设计模式。请注意，这些设计模式对其他异步代码的其他用例都不会真正帮助。

1。init功能

正如您在自己的代码中所展示的那样，这是一种方法。基本上，您有一种异步方法来初始化资源。这类似于jQuery的.ready()函数。编写初始化功能有几种方法。最直接的可能是接受回调，让您继续进行逻辑：

class Foo {
    init (callback) {
        connectToDB().then(db => {
            this.db = db;
            callback(this);
        });
    }
}

用法：

let foo = new Foo();
foo.init(async function(){
    await foo.save();
});

2。建筑商模式

这种设计模式在Java世界中更为常见，在JavaScript中较少见到。当您的对象需要复杂的初始化时，使用构建器图案。需要异步资源正是这种复杂性很好地适合构建器模式：

class Foo {
    constructor (db) {
        if (typeof db === 'undefined') {
            throw new Error('Cannot be called directly');
        }
        this.db = db;
    }
    static async build () {
        let db = await connectToDB();
        return new Foo(db);
    }
}

用法：

Foo.build().then(foo => {
    foo.save();
});

3。按需初始化/隐藏的init

如果您的初始化杂乱或复杂，并且您希望使用更清洁的API，则此设计模式很有用。这个想法是缓存资源，仅在尚未初始化时初始化它：

class Foo {
    constructor () {
        this.db = null;
    }
    db () {
        if (this._dbConnection !== null) {
            return Promise.resolve(this._dbConnection);
        }
        else {
            return connectToDB().then(db => {
                this._dbConnection = db;
                return db;
            })
        }
    }
    async save (data) {
        let db = await this.db();
        return db.saveData(data);
    }
}

用法：

async function () {
    let foo = new Foo();
    await foo.save(something);  // no init!!
    await foo.save(somethingElse);
}

---

奖金

如果您回顾一下Init函数示例，您会看到回调看起来像是控制结构 - 有点像while()或if()。这是匿名功能的杀手特征之一 - 创建控制结构的能力。标准JavaScript(例如.map()和.forEach()(，甚至很好的.sort()。

，都有很好的例子

您可以自由地创建异步控制结构(coalan/async和async-Q库是此的很好的例子(。而不是：

if( ! (await this.tableExists()) ) { ...

您可以将其写为：

this.ifTableNotExist(()=>{
    return this.createTable();
})
.then(()=>{ ...

可能的实现：

  ifTableNotExist (callback) {
      return new Promise((ok,err) => {
          someAsyncFunction((table) => {
              if (!table) ok(callback());
          });
      });
  }

异步/等待只是异步编程中的一种工具。并且本身就是一种设计模式。因此，将自己限制在异步/等待中限制您的软件设计。对匿名功能感到满意，您会看到很多重构异步代码的机会。

奖金第二

在按需启动模式的示例中，用法示例通过使用等待来依次保存两个数据。这是因为如果我们不等待完成代码，则代码将两次初始化DB连接。

但是，如果我们想加快代码并并行执行两个保存怎么办？如果我们想这样做怎么办：

// Parallel:
await Promise.all([
    foo.save(something),
    foo.save(somethingElse)
]);

我们可以做的是我们可以拥有.db()方法检查是否有未决的承诺：

// method to get db connection:
db () {
    if (this._dbConnection !== null) {
        return Promise.resolve(this._dbConnection);
    }
    else {
        if (this._dbPromise === null) {
            this._dbPromise = connectToDB().then(db => {
                this._dbConnection = db;
                return db;
            })
        }
        return this._dbPromise;
    }
}

实际上，由于我们可以在诺言中称呼.then()的次数没有限制，因此我们实际上可以简化这一点，只是缓存了诺言(不知道为什么我以前没想到(：

// method to get db connection:
db () {
    if (this._dbPromise === null) {
        this._dbPromise = connectToDB();
    }
    return this._dbPromise;
}

Answer 2

db.js

const options = require('../options')
var mysql = require('mysql');
class DataBase {
  constructor(options){
    this.options = options
    this.db = mysql.createConnection(this.options)
  }
  connect(){
    if(this.db.connected){
      return Promise.resolve(this.db)
    }
    return new Promise(function(resolve, reject){
      this.db.connect(function(err) {
        if (err) {
          reject(err);
        } else {
          console.log("Connected to MySQL!");
          resolve(this.db);
        }
      });  
    })
  }
}
module.exports = new Database(options)

index.js

const db = require('./db')
db.connect()

anywhere.js

 const db = require('../db')
 async function(){
   await db.connect()
   db.db.doWhatever()
 }

显然，您只需要在启动时要进行的操作中的冗余db.connect((，例如，在路线上，您已经知道它是从启动中连接的：

routes.js

const db = require('../db').db
app.get('/posts', async(req, res) => {
  const posts = await db.query('select * from posts')
  res.send(posts)
}

Answer 3

如果某些内容是异步的，则无论如何都必须使用" then" thens" async/wait或回调(。现在，您在JavaScript中拥有"类"并不意味着您必须使用它们。我不是课堂和古典OOP的忠实拥护者。
我以不同的方式写东西...人们皱眉了，但无论如何都是生活。您写的课程似乎没有任何状态，我也看不到使用课程的意义，但这是偏好的问题。
看起来是服务类。
不使用课程的一件好事是，您不需要将所有内容都带有丑陋的"这个"狗屎。您可以在具有功能的模块中写上面的代码。

还要记住，如果该功能为异步

，您不需要明确返回承诺

const { log, error } = console;
async function promiseMe(shouldIthrow) {
  if (!shouldIthrow) {
    return 'I Promise you'; //See? no Promise, it will be wrapped in a promise for you
  } else throw Error('I promise an Error')
}
// somewhere else
(async function run() {
  try {
    const result = await promiseMe(false)
    log('Look mum, a promise', result);
  } catch (r) {
  }
})();
// Or "then"
promiseMe(false).then(value => log('Look mum, a promise'));
promiseMe(true).then(_ => { }).catch(e => error('Oh men!'));

现在，这就是我要编写您要的代码的方式(实际上是工作代码，虽然没有用(

const db = {
  query: function (sql, callback) {
    //sanitze your sql
    callback && callback({ result: 'database deleted' });
  },
  initConnection: async function () {
    !dbStarted && (dbStarted = true) && (log('DB Started'));
    return db; 
  }
}
function Completer() {
  let resolve, reject;
  const promise = new Promise((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { resolve, reject, promise };
}
//Higher order function to decorate anything that uses a db
// to ensure there's a db connection 
function withDb(decorated) {
  return async function decorator() {
    await  db.initConnection();
    decorated() 
  }
}
const tableExists = withDb(async function tableExists() {
  log('tableExists');
  return false ///whatever code you need here
});
async function createTable() {
  log('createTable');
  return false ///whatever code you need here
}
function saveHandler(completer){
  return function (data) {
      data.result && completer.resolve(data.result);
      data.error && completer.reject(data.result);
    }
}
async function save(data) {
  try {
    (!await tableExists()) && await createTable();
    const completer = Completer();
    db.query('DROP DATABASE databasename;', saveHandler(completer)); 
    return completer.promise;
  }
  catch (e) {
    //Nah no errors
  }
}
save('blah blah').then(result => { log('[Saved?] oh no:', result) });
// or
(async function run() {
  const result = await save('blah blah');
  log('[Saved?] oh no:', result);
})();