Nodejs代码里如何保证缩进层级不会太多？

Nodejs代码里如何保证缩进层级不会太多？

因为是全异步的，所以感觉动不动就是多一个回调，搞的层级有点多，代码复杂的时候很头疼。。。。 我已经用了async框架中的auto等方法去降低层级，但是感觉还不是很给力的样子。比如我用的是node中的标准的mysql库，动不动就是一个异步sql查询。又会慢慢的增加层次。所以。。。

问下，大家都是怎么搞的。有没有推荐的组合框架之类的？大家都是怎么搞的？

6 回复

Node.js代码里如何保证缩进层级不会太多？

在Node.js中处理异步操作时，常常会遇到回调地狱（Callback Hell）的问题，导致代码缩进层级过多，可读性降低。为了改善这个问题，可以使用多种方法来简化代码结构和减少嵌套层级。

1. 使用Promise

Promises 是一种解决回调地狱问题的流行方式。通过将回调函数转换为返回值的方式，Promises 可以使代码更易于阅读和维护。

const mysql = require('mysql');
const util = require('util');

// 创建连接池
const pool = mysql.createPool({
    host: 'localhost',
    user: 'root',
    password: 'password',
    database: 'test'
});

// 将query方法转换为返回Promise的形式
pool.query = util.promisify(pool.query);

// 示例：执行两个异步查询
async function runQueries() {
    try {
        const [rows1] = await pool.query('SELECT * FROM users WHERE id = ?', [1]);
        console.log(rows1);
        
        const [rows2] = await pool.query('SELECT * FROM posts WHERE userId = ?', [1]);
        console.log(rows2);
    } catch (error) {
        console.error(error);
    }
}

runQueries();

2. 使用async/await

async 和 await 关键字与 Promises 结合使用，可以使异步代码看起来更像同步代码，从而避免回调地狱。

async function processUser(userId) {
    try {
        const [rows1] = await pool.query('SELECT * FROM users WHERE id = ?', [userId]);
        console.log(rows1);
        
        if (rows1.length > 0) {
            const [rows2] = await pool.query('SELECT * FROM posts WHERE userId = ?', [userId]);
            console.log(rows2);
        }
    } catch (error) {
        console.error(error);
    }
}

processUser(1);

3. 使用第三方库如async或bluebird

这些库提供了更高级别的抽象，帮助你更好地管理异步操作。例如，async 库中的 series、parallel 和 waterfall 等函数可以帮助你更清晰地组织异步流程。

const async = require('async');

async.series([
    function(callback) {
        pool.query('SELECT * FROM users WHERE id = ?', [1], callback);
    },
    function(callback) {
        pool.query('SELECT * FROM posts WHERE userId = ?', [1], callback);
    }
], function(err, results) {
    if (err) return console.error(err);
    console.log(results);
});

总结

通过使用Promises、async/await 或第三方库，可以有效地减少Node.js代码中的缩进层级，提高代码的可读性和可维护性。选择适合项目的工具和方法，可以使异步编程变得更加简单和直观。


去搜索“js异步回调解决方案”

async … https://github.com/caolan/async

或者 ,本社区用的eventproxy https://github.com/JacksonTian/eventproxy

已经用了async，但是感觉还是太多了点，也可能是我async用的不够深的原因。 eventproxy之前没了解过，等下了解下。 谢谢啦

好的，谢了

在Node.js中处理大量的异步操作确实容易导致代码缩进层次过多，从而影响代码的可读性和维护性。这里有几个推荐的方法来简化代码结构，减少嵌套层级：

  1. 使用Promise：Promises可以有效地管理异步操作，使得代码更扁平化。

    const { Pool } = require('pg'); // 假设使用PostgreSQL
const pool = new Pool();

function queryDatabase(sql, params) {
  return pool.query(sql, params);
}

async function fetchData() {
  try {
    const result = await queryDatabase('SELECT * FROM users', []);
    console.log(result.rows);
  } catch (err) {
    console.error(err);
  }
}

fetchData();

  2. 使用async/await：async/await是基于Promise的一种语法糖，使得异步代码看起来更像同步代码。

  3. 第三方库：如bluebird提供了比原生Promise更多的功能，包括一些实用工具函数。

  4. 组合式框架：

    • async模块的.series, .parallel等方法。
    • co模块可以帮助将generator函数转换为Promise链。
    • koa框架内置了Generator支持，并且非常轻量。

  5. 引入一些现代库：

    • sequelize（ORM）：提供更高层次的抽象，减少直接SQL操作的次数。
    • apollo-server（GraphQL）：对于需要大量数据交互的应用程序，GraphQL是一种更高效的选择。

  6. 使用类或函数封装重复逻辑：通过把常用的数据库操作或者网络请求封装到单独的函数或类中，可以显著减少代码中的冗余。

这些方法都可以帮助你更好地管理异步代码，减少缩进层级，提高代码的可读性和维护性。希望这些建议对你有所帮助！

回到顶部